What's up engineers? Any devdan here. Today, I'll be rewriting my plan meta skill from the ground up. Why is that? It's because the recently banned Fable five and Mythos class models enable a whole new level of planning and great planning is great engineering. Now, who cares about the plan skill? Why is planning so important? Your planning skill is one of the most important tools you and your agent [music] have. Most engineers hand this off to the model, they hand it off to their agent to coding tool, their cloud code, open code, codex, which [music] I see as a massive mistake because it assumes the model knows what you're looking [music] for. This is part of the mass deprecation of raw engineering talent and skill we're seeing across the industry. This is an example of engineers becoming too reliant on models and agents. [music] You should not outsource your thinking. You should not outsource your planning [music] because great planning is great engineering. This is going to be a slow in-depth
[00:01:00] agentic engineering dev vlog. So, if you're waiting for some get-rich-quick [music] five coding hack or a flashy multi-agent demo, it's time for you to click away. This is for agentic engineers who know [music] that knowing what their agents are doing is key for success at scale. Let's start where all the best work starts. [music] Let's think, plan, and build a next-generation Fable five and Mythos [music] class level planning skill. First things first here, we're going to spin up a brand new directory. I'm going to pull in some existing resources. [music] Uh we're just going to start from scratch here. So, I'm going to move into my projects directory. I'm going to make a new directory called [music] plan F3. And I'll explain this in a moment. We're going to break out VS [music] code here. I am no longer using cursor. For quite some time, I was using cursor for their [music] tab completion model. They have abandoned that, as far as I know, and they've gone all in on agents. [music] Everything's an agent. Everything's an
[00:02:00] agent interface. That was really the last reason I was using Cursor. The first thing I like to do when I'm building an important, critical meta skill, a [music] skill that's going to be reused over and over and over, and a skill that outputs other documents, right? [music] This is why it's a meta skill. The first thing I like to do is just write. This is probably going to surprise some engineers watching the channel. It won't surprise many [music] senior engineers. I'm just going to open up a document called raw. md and just start writing about what I'm going to do. This is going to serve as [music] context for not just my agents, but for myself as well. So, this is plan F3 Mythos class planning meta skill. And plan F3 stands for [music] plans for Fable thoughts. So, that's what the F3 is. It's three F's, FFF. The whole idea here is a brand new slash [music] plan F3 skill that we'll be able to use, and we take in a user prompt. This is our API. Let me go ahead and bump up the screen size here [music] a little bit. And I actually want to add one more thing here, questionable, which lets us uh kick off an interactive question
[00:03:01] session [music] with our agent. That's the API, and we're actually skipping a couple steps here. Let's go ahead and just talk about what [music] is this? As I mentioned, like great planning is great engineering. And with these brand new Mythos class models being released >> [music] >> and banned and unbanned, there is a new level of capability that is unlocked by these models. As we talked about in our previous video, the more upfront [music] investment you put into your planning, the less reviewing you have to do. And with every new Mythos class model, [music] this will become more and more true, and more capability will be in your hands, but only if you know how to extract [music] it. So, uh what is this? We are pushing against the two constraints of agentic engineering, planning and reviewing. Initial investment in a great plan is the difference >> [music] >> between a great engineer and a mid engineer. By investing more effort up front in planning, [music] we improve on both constraints. Because as mentioned, great planning is great engineering.
[00:04:01] And when you have a great plan and you communicate what you want done, you are doing less reviewing. Great planning also yields less reviewing as model capability increases. So, a lot of engineers just hand off planning [music] to their model, to their agent with no structure attached. This forces the model to work and compensate and guess at what you're looking for. It also forces your agent to coding tool. For instance, if you use Cloud Code, this {slash} plan, who knows what's happening here. You actually don't know. And that's okay for the kind of surface level results, but if you really want to agent engineer and control the results [music] end to end, you must write your planning skill, your planning prompt, your planning template. And so, let's talk about the models. We've been planning and we've been writing specs for a long time now. What's really changed here >> [music] >> is the new Mythos class models. So, the recently banned April 5 and Mythos class models unlock next level of >> [music] >> planning ability, which lets us reach
[00:05:02] new heights to specify the exact outcomes we're looking for. Something like that. You get what I'm trying to say. These new models unlock a new level of planning accuracy, [music] planning ability, which lets us specify the exact outcomes we're looking for. So, that's the idea here. And whenever you're planning, whenever you're working with agents, you're trading off three things. And I just want to make this super clear of the trade-off trifecta. We talk about this a lot on the channel. This is perf, speed, cost. This new plan template trades [music] speed and cost for optimal performance. I think this is a good mindset to be in in general [music] when you're using state of the art technology. Just make the sacrifices you need to get state of the art results. Usually that means sacrificing speed and cost. [music] So, we're spending to win here. We're not holding back. And we're spending both time and cost, and of course cost comes in the form of tokens. And yeah, just to make it super clear, cost tokens. [music] Priorities, performance greater than speed greater than equal to cost. Now we kind of understand the setup. Whatever
[00:06:01] work you're doing and whatever work I like to do, I like to just sit down and just type it out, right? Like think through why we're doing this, what we're doing. We're building a new plan skill for this new class of models that's [music] emerging. And they unlock the next level of planning ability, which lets us specify the exact outcomes we're looking for. This is the hallmark of these new state-of-the-art models. You can ask for a very specific thing, and if you know how to ask for it, if you can write [music] big enough specs, complex enough specs, if you're doing interesting enough work, these models can [music] get the job done, but only when you ask them the right way, only when you present them with the right information. So this [music] is our API. We're going to run any coding agent. I like to use the PyCoding agent, and [music] I like to use Claude code, but use your favorite, use Open Code, use Codex, use whatever. You'll notice something weird here as we start working through this. You can already see that I am actually [music] typing. I'm not talking into the work flow, I'm not having an agent do all this work for me right away, and reuse a bunch of skills. We are going to do that, we're going to
[00:07:00] of course move at the agentic speed, but only after we have the foundation up. And this is one of the ideas I wanted to bring to you here. The more you're going to be using a skill or a resource or an agent harness, the more time and investment you should be putting into it. And the plan prompt is one of the most important [music] tools you and your agents have. It details how good your results are going to be up front. As these models progress, your plans that detail the work to be done are potentially the most important context your agents can and will write and read. And so what I like to do with my work is I like to do something called property-based engineering. What I'm going to do do is we have our priorities, now we're going to jump into our property. So, let me just copy in my kind of V1 spec. If you've been following the channel, you've seen this format a million times already. I've used this prompt thousands of times. It's quite simple. We have a plan, we have our purpose at the top, we have our variables, which are just the user prompt, we have our output, some instructions, just bullet points to
[00:08:00] guide the agent. We then have our workflow. This is the step-by-step actions our agents take to get the job done. We then have the most important piece, [music] the plan format. Now, this plan format changes my results completely across every execution. So, this is not just an ordinary prompt or skill. As I mentioned, this is what's called a meta skill. It is a skill or prompt that creates another prompt or skill. And in this case, we have templated our engineering into this plan format. These are the same ideas we've been talking about on the channel for a year now. They're still equally as relevant because the information system around them has not changed. It's only that we can push this plan format, as you'll see in this video, a lot further. You can just see this, you know, I have created a dedicated format, and [music] the model must do two things. It must fill in the template sections, and then it must leave everything that's not templated where it is. So, what this does is, it's going to give us this exact format. [music] And this is what it really means to template your engineering. We're teaching the agent how we engineer. So, this is the V1 plan. I wrote this spec over a year ago
[00:09:01] now, and it's paid me dividends and dividends and dividends. Of course, I have enhanced versions, I've created some YAML specs, I've created some HTML specs, [music] some image-based specs, but this is the core format. 80% of this has not changed, and today we're going to enhance it for the [music] new Mythos class level models to get more value out of our plans. And so, what are the properties we want this new plan to have? Let's just go through this piece by piece, and then we'll order it. This is going to be the structure that makes up our new plan template, the format that our agent is going to reproduce over and over and over to to us that consistent set of results. So, uh let's just talk about the properties really briefly here. I'm just going to say to capture intelligence sealing of Mythos class models, we need to improve our planned skill / template to have specific properties, aka sections. It's always important to talk about your audience. So, the output of our plan will be created, updated, and consumed by the agent drive factor. And this is
[00:10:00] the audience for who we're building everything for now, which is the engineer, so your I, the engineering team, so all your co-workers, and then finally AI agents. So, this is who we're building for. And it's important to know who's reading this because a lot of engineers using the technology, they're just building for the AI agents. Others are over-indexing on their engineering team. Others are over-indexing on themselves. It's important to emphasize that this is for the trifecta. It's for you, it's for your engineering team, and it's for your AI agents. And we'll just make that super clear. So, let's list our property. So, what do we want inside of this plan format? What are we putting in plan F3 [music] skill, plans for Fable 5. Let's just walk through it. So, I've been thinking about this for a while. I'm really happy to be taking some time [music] with you to kind of walk through this process. My spec prompt and its variants [music] have been super, super valuable, but they haven't really changed that much. Here, we're going to update it for this new class of [music] models, the Mythos class models, Fable 5 being the first one of them. The whole idea here is we can really push the token usage of these
[00:11:00] models. The way we're thinking about this is we're not worried about tokens, not worried about speed. We want performance over everything. I want the best possible plans. I want the agent to internalize every single fact about the codebase, about the work, about the upcoming spec that we're writing. Let's just think through like, what is the best possible version of that from first principles? How can we spend tokens to get the best possible results? We're scaling our compute to scale our impact. So, let's think through these sections. I want a embedded checklist per task and per phase. And before that, we'll want a per phase and per task per phase breakdown of work. So, we're using HTML again. This is going to be good for the agent trifecta, you, your engineering team, and AI agents because you'll be able to open this up and see visual rich HTML. And we also want images embedded. An image is worth a thousand words. Let's put that into action. Great great plans with images and HTML. I want to give my agents the ability to be
[00:12:00] absolutely clear on what's getting built. So, I want a questions and answers section. We want to make sure we're not over indexing to human in the loop. We're always pushing towards ZTE, zero touch engineering. We want to get out the loop, but we want to be able to step in the loop when the work isn't intense enough and when the time is right. So, I'm going to say this is togglable. I want a rich updatable header metadata. And what do I mean exactly by that? So, I want created, modified, I want commits, [music] I want the agent name, I want the session ID of that agent. I want back references and forward references. And let me make it super clear which one of these are a list because this could be potentially updated several times. So, basically everything but the created date is going to be a list, right? So, a list of modified times, a list of commits, a list of agent names, so on [music] and so forth. Great. And this is all going to be updatable header metadata. So, once again, I'm leaning on the fact that these models are becoming more intelligent, more powerful, and again, I'm not optimizing for cost here. If I
[00:13:00] was optimizing for cost, we wouldn't have images getting generated in this plan. It wouldn't be HTML first. We wouldn't add all this header metadata. But what I'm doing here is I want the best performance. I want my plans to look forward, to look backward, to existing documents. I want this agent to work and build the best possible plan. That's what we're doing here. Of course, we want [music] validation and testing sections that prevent completion [music] until done. You know, this is your classic loop that everyone's all of a sudden so obsessed with. We've been talking about this for over a year now. This is a closed-loop structure. You want your agent to have very, very clear outcomes to loop on if the work is not completed. We want our new [music] versus existing file section. Very powerful. I want synced HTML and image [music] styles. Speaking of images, I want focused images embedded. Probably have to break this down a little bit more. We'll just keep it high-level for now. Yeah, classic stuff. Purpose, problem, solution. So, let's add a little bit more detail we can move on to actually writing this new skill. So, this is all preamble, right? This is just raw information dump. I'm priming
[00:14:02] my context and I'm letting agents that will be working on this with us understand what we're doing and why we're doing it. Once again, like we're thinking. Great engineering is planning. Great engineering is thinking. What do you want to see? Why do you want to see it? What's [music] enabling this thing that you're trying to do? What are your priorities? What are you willing to give up to get the job done? Make things crystal clear in your work. And the best way to do that is just by sitting down to write. >> [music] >> Write, type. Usually, I'll have my, you know, I have a whole stack of a bunch of notebooks here. Often times, I don't even [music] start with a markdown file. I just write. Like I I literally just like write things out. Which I know is probably mind-blowing for some engineers who are like blasting off 500 agents and using [music] every framework and workflow and parallelizing scheme under the sun. That's great. I feel you. Go for that. I do think that [music] the true differentiation for engineering is this now. It is sitting down, thinking of interesting, [music] novel problems and interesting, novel solutions, and then being able to write about it clearly and
[00:15:01] concisely, and then build it with your agents and iterate with it with your agents. [music] And of course, one of the most important pieces of that that can really improve your review constraint is where it all begins. It's planning. [music] Great planning is great engineering. I'm going to say it again and again, and I want you to be tired of me saying it >> [laughter] >> by the end of this video, but, you know, I want to nail this point home. [music] The future is created by those who plan it, not those who vibe code it. >> [laughter] >> And I know this is probably controversial. Don't care. That's how it is. What I'm going to do here is just do a quick ordering. So, I just want to order the sections and mention to the agent this will roughly be the new prompt template for the new plan F3 meta skill. We want our headers come to the top. Purpose, problem, solution comes next. I'll just be super clear here. Title, H1 title. We want our phases HTML [music] first. I'm just going to leave this as properties and just organize this a little bit first. Go to the bottom. Sync images [music] and style, that can go further up. Validation
[00:16:00] section, new file section. Okay, tasks here. [music] Sync. Okay, that's good enough. Let's start writing this plan. Now, we're going to boot up an agent. So, for the first time, 30 minutes for me, probably less for you. I'm going to try to cut this video down to make it as concise as possible for you. Now, we're going to start bringing agent into the picture once we have a vision. And now our agent is going to [music] help us a little bit. So, I'm going to use my meta skill. So, this is my skill that creates other skills. And I'm just [music] going to say create plan F3 as an empty uh templated [music] plan. Leave all sections blank, but include each section templated skill. This is on high thinking mode. We're running Opus 4.8. Again, hopefully by the time you're watching this, you'll have access to Fable. Really looking forward to that being re-released. The kind of noise around this has been really interesting. It looks like, you know already, right? I don't need to re-explain this or update to you. You're in the future. You probably have more information than me. interesting part here is that apparently the jailbreak isn't sophisticated. [music] This was reported to the US government by an Amazon employee, apparently the Amazon CEO. So, that doesn't look good. Someone here is either very
[00:17:01] inexperienced with what's going on, or they're just lying. I do believe here that the US government is acting a little fishy, but I don't want to say too much here. I don't want to get too political. I hate mixing engineering and politics, but um you know, we're at this really interesting place. I don't really see anything that Anthropic has done wrong here with this model. In fact, the guardrails are too strong [music] for good reason. They have good reason for this. Anyway, you'll likely have access to this by the time this video is released. If not, then things are probably getting interesting. [music] And by interesting, I mean political and annoying. So anyway, we have our new F3 skill. [music] Create this locally. By default, my agent just throws this into my global directory. Right now, we just want this in our local directory just so we can see it, observe it, operate on it. There we go. So let's go ahead and crack this open. [music] So we're going to simplify a lot of this. It is definitely overdone. We have a lot of header hooks and information here. And let's just go ahead and start [music] using what we have before here. Plan F3 looks good. And then we have our blank [music] sections. Okay, I'm going to say
[00:18:00] add variable section and argument hint user prompt. And we want [music] questionable. This is one of those funny cases where using Opus is complete overkill. As we talked about in our previous video with Fable 5 getting banned, that level applies to all levels of models. This is overkill for Fable. This [music] is relatively stupid work for Fable to be doing. But anyway, not super concerned about that. It's part of our subscription plan here. So we have this great write-up. Let's >> [music] >> start building this into our skill. So we have our variables. What I'm doing right now is just [music] dialing in and copying in some information from our previous specs because a lot of that upfront structure [music] is the same. So plan three, questionable, dollar sign two. Output directory is going to be, of course, that specs directory. And now we have our classic structure. Purpose goes at the top, [music] and then we have instructions. We're going to get rid of examples and report format. And we're going to focus on these key sections [music] here. I like to use QQQ as my primary search markers to jump to. [music] So we're just kind of filling
[00:19:00] that out here before we start filling in our sections. Fantastic. This is all clear. And now I want my agent to just get updated here. You know, we have a little bit of context [music] for it to work with. What we've done here by also writing out all the properties we want our system to have, we've also kind of detailed the work that needs to be [music] done. This plan format needs to be in HTML. We need an image generator, right? So, we need to pull in some type of image generation. We're going to be using Chat GPT images, [music] too. This is the best image generation model on the market right now. It gives you exactly what you're looking for. So, we're going to use that to generate our images. And then we're just going to, for all of our output plans, the thing that gets generated from our meta planning skill, we will output structured HTML. And then we have existing sections, much like our existing spec prompt. I'm just going to copy our previous version here for our purpose, and just kind of write out what this is doing. Create a detailed implementation plan based on the user's request. We're going to dial this in a little bit based on the user prompt variable. Analyze the request, think through the implementation approach, and
[00:20:00] save the output document to this. And this is workflow information, so I'm going to go ahead and cut this. And [music] there we go. Follow the instructions and work through the workflow to create the plan. Great. So, I'm going to refer to these exactly. With these powerful models, this is unnecessary, but I'm doing this not just for the agents, I'm doing it for my team and myself. So, that's the purpose of this. Create a detailed implementation plan based on the user prompt variable. This is great. Now we can go ahead and start putting through our instructions. So, the instructions are like high-level information. They'll oftentimes overlap with the workflow, so you can see here in our V1 spec, the workflow is the actual [music] steps, but the uh instructions kind of aid the steps. So, this just gives us a free-form spot [music] to work piece by piece. So, we're going to start with that. And the whole time here, as I am reusing the key pieces, updating it, I'm thinking about the next generation capability of the Mythos class models, okay? I'm thinking how far we can push [music] this, and how we want to organize the skill so that the skill is, in fact, a unified
[00:21:00] stand-alone skill. I don't like having cross-dependencies in my skills. [music] And so, we're going to have image generation, we're going to have our create workflow, and one more thing actually we should embed in our raw is our workflows. This isn't just going to be a make a new plan skill, it's also going to be our skill that updates our plans, our skill that builds the actual engineering work, and the skill that generates images. We're kind of overloading the skill a little bit to be everything related to writing this great plan for Fable 5 level models, right? For Mythos class models. So, the workflows we want to create plan, we want update plan, we want to update references because it's not all just about updating the plan. We want our agents to be treating this as an artifact, a living artifact in the code base. Agents are good enough now, we don't need to worry about them making mistakes here. They should be updating our back references. So, this plan referencing previous plans, [music] AI docs, so on and so forth, and forward references. So, when a plan in the future gets created or some AI docs in
[00:22:00] the future gets created, we want this updated. [music] And so, we need an update references workflow. We want a build plan workflow, and then image generation [music] workflow as well. Title skill. So, let's just like look through the instructions here. We want to make sure that this is still relevant. Uh we do not need task type here. Think deeply, ultra think. Remember the ultra think keyword? Back in the Cloud Code days, that was nice. I think now that actually still Take it rid of that. Okay, nice. It is still here. Maxes out thinking for that one execution. And that's fine for the plan, we do want to use maximum compute. [music] So, if we're using Cloud Code, this will kick that off. And what else here? Do we have Yeah, so we're not using periods at the end [music] here. Get rid of that. Explore code base, understand patterns, follow the plan format. Do not have plan format here. Yep. So, uh we're going to call [music] this plan template to make this super clear. And we are going to reference this section exactly. [music] Create a comprehensive implementation plan, include all the required sections, and conditional sections. I don't think we need this. We do want that. Another developer could follow it. Good code examples, pseudo code, make sense. Consider edge cases here. Yeah. Okay.
[00:23:00] So, that's good enough for the instructions. Right, we're basically just saying pay attention to the incoming prompt, research the entire code base, explore the code base, existing patterns, documentation, previous specs, architecture. And so this is like, you know, a great spot to do some customization where you would put your own workflows. And so plan format, this is the most important piece. So I'm going to start by writing this out in a markdown format just like our markdown version, right? You can see here we have a nice templated version. I'm just going to copy this in and make some changes to it. I'm going to paste this in and the plan format is what our agent is going to mirror and update. So you can see that everything inside of this is going to get templated and replaced. And so I'm going to add a bullet point here for that because I don't think that's actually clear here. And follow the [music] plan format below, okay, when dating format place everything [music] within the quest with the quest embedded inside. So this is the template instruction. We're making it super clear that this is when the agent should update this part of the prompt. This is also template or engineering versus
[00:24:01] leaving something [music] the same. Okay, so you can see here we have some conditionals. We have a list. For now, we're going to write this in markdown format so it's super clear and then we're going to have our agent, right, Opus 4.8 is going to update this structure for us into a HTML format cuz that's one of the properties we're going for, right? It's HTML first for ourselves, for our team, and for our agents. [music] And then if we go to the task here, I want to make a couple updates to this structure. So we don't have this complexity stuff anymore. So I'm going to get rid of solution approach here. We do want relevant files, but I want to write this out. [music] So this is existing files and then we don't need this. So where we want an existing file section and a new file section. List new files. [music] And again, we do not have this conditional. We are always going to have a phased [music] approach. I'm going to delete this and this kicks off our implementation phase section. And again, like we're just building up the exact format we want to see every single time for consistency and it's a great structure of how we would actually do our work, right? A phased approach, break it down into chunks, and this is
[00:25:01] great for a validation, as you'll see, in creating powerful closed loops, because every phase should be self-contained and validatable. So, we'll get there in a moment. Right now, we have phase one foundation. I actually want to break this up. So, this is a phase one name. I don't want to over prescribe what the agent should do here. So, I'm just going to break this up. Phase three name. And I want bullet points here so that we have a live tracking. And this is, you know, one of our properties. Here we go, embedded checklist. So, you know, another property we want this to have, because our agents are just good enough now, is that this spec is a living artifact. So, our agents are updating this spec and all the work live, as it works through it. And then, these sections, we do not want these to be separate. You see we have our H2s. I want this step-by-step task under every phase. So, every phase has step-by-step tasks. Testing strategy, this is good. I actually want to keep this, [music] but get rid of that if, and then I want to move this entire step-by-step task into our phase work. Just going to paste that there. Phase one. Move this up. Implementation
[00:26:02] phases. [music] Execute every phase and sub and task step-by-step in order, [music] top to bottom. So, this is an ordered list of execution. As needed, I want n minus [music] one, and I'm going to put this in our syntax here, right? So, the agent updates this. Testing [music] strategy. Describe the testing approach, and this is also a H3. Really paying attention [music] to the H3s here. Okay, that should be okay. Yeah, we can pull this up here. Specific commands to validate [music] work, and then continue. Specific commands to validate the completion of this phase's tasks. [music] So, that's the idea. Discuss, break down how and what technology being used to test, validate work is complete. Be sure cover edge cases as applicable. Some lightweight templating here. So, now we have our testing strategy per phase, and I'll add a description here. Describe the work to be done in this phase at a mid to high
[00:27:00] level. And then we have our step-by-step tasks, which I don't think we need. So, I'm just going to get rid of this. Continue adding additional tasks. Great. Okay, so this is our phases, right? So, we just wrote out our phase structure. So, that's pretty important. And then what I'm going to say here is repeat structure from phase one. And same thing for phase three. And then, of course, we'll do the exact same thing phase n minus one, name, right? Repeat structure from phase one. So, I'm going to get rid of acceptance criteria here. We're just going to use validation commands to validate the plan is complete. Validate the work inside [music] each phase is complete. And then continue for each valuable command to prove that each phase [music] is complete. And I'll say feel free to mirror from the testing [music] task from each phase, because it will likely be the same stuff, right? And then we have a note section that that all looks good. So, we're really just thinking through the hundreds and hundreds and thousands of times we're going to be using [music] a skill like this. We want it to be crystal clear how to output the result we're looking for.
[00:28:00] Okay, so we're putting a lot of upfront investment. Again, you know, I know some engineers watching this are thinking, "Holy crap, I could have live coded that two seconds." [music] That's not what this is about. You don't get your specific results by leaning on the agent like that. Thinking through this, right? We have task description, objective. I would like a problem and solution here. [music] I think this is a cleaner approach. Describe the problem we're going to solve. And what do we want in two to four sentences? [music] This is a what I like to call a restriction. You want to be really careful with the restrictions you're placing on the model. Maybe uh it helps a lot to have a longer breakdown here. Sometimes you don't need it. I will bump this up to two to eight. And [music] clearly state what will be accomplished when the plan is complete. And I'll do the same thing. It's four sentences. And okay. Okay, that's good. [music] Problem, solution, relevant files, existing files, new files, implementation phases. So, we can break our work into phases. We do need to nest [music] our tasks just to make it dead clear here. Great. And then we repeat from phase one. Again, we're templating, but we're also talking to an intelligent model that knows how to set this up very
[00:29:00] quickly. [music] So that's good. And then validation commands. We have notes and let's go back to raw and make sure we have everything. This is going to be a good time to bring our agent into the picture because we have our structure. Just get a [music] net and I'll do a GCP main. Just make sure that we have a starting place and I'll copy in a simple get ignore file and just [music] get something committed here. We're putting in get just to roll back anything we don't like, which is unlikely to happen, but we do it anyway. And questionable, I do want to default to false for input variable here. This is looking pretty good. I will pull the workflow just to give our agent a starting place here. Analyze the requirements, parse the user prompt to understand the core problem, desired outcome, explore the code base, design solution, document plan, generate files, save, and run the report. We do not have a report anymore, so we'll say provide us some real key [music] components. Okay, that's good for now. This gives us a working skill. So now that we have a great foundation, we can start pulling in our agent to [music] [00:30:00] speed up our vision, our foundation, and our plan for our plan for our plans. This all looks good. We are missing some sections, so why don't I do this first? Let's go [music] HTML first because this is a key upgrade. We're spending tokens to get better results and we want to communicate for us, our inch team, and our AI agent, so let's update this. So read raw, understand [music] our vision, read our previous gen spec, and our work in progress skill.md. [music] Stand by before we start. Just reading, I wanted to ingest this [music] context. And by this, we're talking about Opus 4.8 running on Cloud Code. And we are running with high effort, if you're curious. [music] I found that this is a great level for most work, probably 90% of work. If I need more intelligence, I like to bump it up to extra high. Here we go. Yep, looks great. It's starting to identify the differences. Ready to start. Let's start by updating our plan format into HTML, our plan template, let's be super
[00:31:01] clear. We need to create a new template structure. Let's use this, update the instructions, and redesign the plan template into an HTML format. So, now we're starting the upgrade process for this plan to be wielded and used by Mythos class models. You know, to be clear, nothing's stopping you from using the meta planning skill we're going to generate plan F3 on lower class models, right? There's nothing stopping you from doing that. The whole idea here is that this plan is going to be most efficient on the top-tier, state-of-the-art, Mythos level models, right? That's the whole idea. So, we're just using some really basic agent of coding. We could pretty much throw any model we want to at but for now, we're just going to keep it simple. We're going to use a single Claude code, and since we're going to walk through this while my agent's doing this, actually, let me go ahead and pull in my image generation scripts. [music] So, this is going to help us generate images and edit images with the GPT image two model. So, you can see exactly how this works. Some 200 lines as an Astral UV single file script, nice and
[00:32:00] simple. This gives our agent the ability to create and edit images. We're just going to drag and drop this directly into the scripts directory. This is one of those nice things where after you build [music] an image generation skill, plug it up to the API, you can just kind of reuse this, okay? So, I'm embedding this right into the skill, and actually need to go one more in here. There we go. And that looks good. Now, let's go ahead and look at the update that was made. Let's make sure that it's clear and concise. [music] Placeholder, replace every HTML first, good. Sometimes these models like go off and do work I did not request. You can see it added this line on questionable. It's fine, we do [music] want this. That's good, so that's been created there. And now we have our plan format [music] in HTML. So, uh first thing I'm going to do is cut out all of this garbage. I did not ask for any styling at all. So, I'm going to tell the agent And this is the problem when you start using agent, you really want to keep it in the loop. Uh remove the styling section [music] completely. We do not have a predetermined styling. All future prompts, be [music] surgical. Do only what was asked for. Let's make our
[00:33:02] metadata header [music] a collapsible details item. Right? So, we're just going from top to bottom here, getting our key sections. [music] We do have purpose, problem, solution. And so, we also do want to have dedicated [music] workflows, which is going to be an important piece of this, cuz that tells the agent exactly how to work. Have this [music] HTML first, kind of a work in progress. Good. Let's add the questionable section [music] into our HTML uh plan template. Place this above the notes section. >> [music] >> And make it conditional only if questionable is true. And so, we have our header section here. Hero image, great [music] purpose, problem, solution, relevant files, existing files. We have this [music] repeat syntax, which is okay. Uh that should be good enough for the agent to understand. And questionables just showed up there. That looks good. Toggable [music] QA. Uh this is a duplicate. Pick one. So, we got rid of that duplicate. Definitely a weird glitch [music] coming out of that model. Usually, it's not that stupid. That's
[00:34:00] our Q&A section. Yeah, you know, I I love this and I hate this about these [music] models. They take one request, they take the context, and they just blow it up. Didn't really want to move on to this step, but it's fine. Here we are. It did [music] a decent job of this. Um I should have been more surgical with my input prompt, saying just do the one thing I requested. But it's fine. So, this is looking good. Plan file, plan output [music] directory. You know, let's work on this. So, maintain a synced visual identity between uh the HTML styling [music] and the generated images. We want a professional >> [music] >> focused I'll also just add minimal theme based on the original user prompt [music] that created the plan. And I'm also going to add a note here. We're moving into our image [music] generation. For every image created, keep them professional and focused [music] on a single on or two primary ideas. Keep text below down by minimizing the total number of words
[00:35:00] requested [music] in the image prompt. The total number of sets of words under 10. And this is so that you don't end up with image generations that have a ton of text all over the place. Goal is to build images that aid the plan and convey core information throughout the plan given the section the image was created for. And I'm just going to keep writing on this because the images is a really key part of this. Build images [music] for professional software engineers to convey exactly what is going to be built. Build, center, and space images properly. Something like that. I think that's good enough. So, that looks good. And now I think we can get rich [music] header sections, embedded images. Let's work on our dedicated workflows cuz this really puts it all together. Okay, let's work >> [music] >> through our workflows. This is similar to our meta skill cookbook pattern, except we'll call these workflows. Create five empty files inside of the
[00:36:01] workflows directory in the skill. Then create a table in our workflow section of when to call each and the file to [music] read given the incoming user prompt. So, that should be enough to get started here. I am [music] going to commit this. And so, now we're going to get our workflows directory and this is how we can really dial in the different agentic workflows that are going to run for [music] this skill. You know, normally I have a spec skill and I'll have like a build skill [music] that details exactly how other agents can build against a given plan. I want this all in one. So, I want this skill to be a unified planning skill for any code base that I can use and deploy for these next generation models. Let's go and take a look at our new workflow section. So, now the workflow is based on [music] a table and we have five workflows. So, we can generate images, we can build against a plan, we can update references because remember this planning prompt [music] is going to maintain and live over the life cycle of the code base. This is now a living artifact. We can update the plan, make
[00:37:01] changes [clears throat] to it, revise it and of course, the most important one, we can create the plan. And so, now inside of create plan, we should have had our base workflow moved into that but it looks like our agent just deleted. Create plan was the workflow we had there. Place it in the file. And I know that's [music] already in the agent's context window. So, now it wants to just recreate that there. This is fantastic. So, now uh it's super clear when to call each one of these workflows, right? And so, this is a way you can just quickly embed multiple pathways for your agents inside of a single skill. Create a workflows directory, specify the exact workflow in each one of them and then let your agent execute [music] each one of them. Fantastic. So, now let's just continue building out our workflows and I think the next most important workflow to work through is going to be our image generation. So, I'll say uh read the scripts and [music] understand how we will create and edit images and then create that workflow. >> [music] >> And I'll say KISS. KISS stands for Keep It Simple, Stupid. Uh agents know this.
[00:38:01] This is an information dense keyword that reminds the agent to simplify [music] the implementation down to the core. And so, now in our image generation, we have this fill or [music] regenerate. Okay, image generation and I want to split this up into two workflows. Let's embed [music] two workflows inside of this file. Create and update based on incoming user prompt. >> [music] >> Let's simplify this a little bit. The create will usually be during the create workflow, the prompt, and update will be explicitly requested or given a change to the plan. Okay, one thing I do want to tweak here, update create a images output output dir in the root variables variables section and reference that instead. Use I'm just going to copy this and I want these to just store underneath plan name in some directory. Yeah, so a couple important pieces here are explore code base step is a little simple. So, I want to add two variables
[00:39:00] here, add AI docs variables AI docs and app docs. These are just two directories that I like to use, reference them in the create plan step two or add steps [music] workflow. And so, these are just two additional directories that are really important for planning and gathering information. AI docs, app docs. So, I'm going to throw it inside my agent and then have it also make sure to read that for the plan and then I can use that [music] in the forward references and backward references section. Awesome. And then I'll add a add an image generation step to the create plan workflow. We'll do that [music] after step four. Also, add the conditional questionable step after this new step five. [music] I think that makes sense. You'll notice a theme as I'm working through this like I'm really paying attention to all the moving parts here. I'm separating the skill [music] into digestible pieces. We have a great plan format that we're going to use literally hundreds and thousands of times as I have used this previous generation spec format. And uh this is going to pay us
[00:40:00] back a lot because now our agents are keeping track of forward references, back references, keep track of all commits, uh modified dates. We're going to have images to aid the system. We're going to have a to-do list [music] built into the spec itself. Great planning is great engineering and we're treating our plans as artifacts. That's one of the biggest jumps [music] with this system. We're using more tokens and we're treating our plans as artifacts, living artifacts in our code base. [music] So, let's go back to raw and understand what's going on. So, we're working on our dedicated workflows. We should get image generation now and we have our updatable headers. Let's create our update references workflow. Create the workflow. This is where we update back references, forward references from another plan. Maintain structure. Subs for no reason. Okay, let's make it clear in our instructions that all metadata except for created ISO is a comma sep list that should only ever be appended [music] to.
[00:41:00] So, this is going to maintain a great log of the agent name, [music] the session ID. Should be able to get away with this. Agent name, ID. Hopefully doesn't break anything. Okay, so that's great. So, now we have that workflow, update references. What else do we need? We have image generation, update plan. Uh let's create the update plan workflow. This is to modify an existing plan. We should update [music] metadata fields. Be surgical with the change to the plan and then update [music] the amend section, which we actually might not have that yet. Yeah, which we need to add to the plan template. Amend is specifically for update plan and update references so that plan contains [music] a running history of changes that occurred after the plan was executed on. So, really important workflow here. Right, if we look at all of our workflows we run in the system, right, our workflow table. We have create, update, update references, build, and [music] image generation. Okay, good. Yep, also append
[00:42:01] only. Exactly. And now we have our update plan. [music] Yep, record amend, record change. Perfect. Okay, that looks good. So, this should be all of our workflows that this [music] plan can execute on. So, that's our dedicated workflows, that's our rich updating metadata, that's our synced HTML images, that's our per phase task breakdown of work, and that's our embedded checklist. Oh, we are missing our build. So, we do not have our embedded checklist yet. Let's go ahead and add that. We do have our validation, but we'll make sure that that's strong enough. First, let's go ahead and run build plan. So, now we need our build plan. This is for the agent that will actually build plan user prompt must contain a path to a plan, or it must be inferred, and then the agent must read all images, and we'll also have it read all back refs. We might want to change this in the future. Right now, we're going to lead toward heavy context, since this agent will have a fresh context window, since all of our agents are focused specialized agents.
[00:43:01] We're sticking to the tactic of one agent, one prompt, one purpose. Uh so, it's going to have back refs. Uh we'll read the back refs, implement [music] step-by-step, update its status, update the phase plus task status as it works, test, report, [music] and I will also say it should announce each phase and task it's working on, or actually just each phase working on. And we should have four states for tasks: [music] empty, work in progress, we'll have done, and then we'll have F for failed. F equals failed, X complete, work in progress, idle. So, now we're going to complete the build plan workflow here. Okay, yeah, so this wasn't even in the spec. This is great. That will now be included. Awesome. All right, let's take a look at what this looks like. [music] Markers, look at the plan, plan output, read absorb context, all images, and I'll say every back reference depth one, execute top to bottom, announce the phase, work in progress, implement [music] the task. Yep, loop till they pass. Okay, do not
[00:44:02] start the next phase. Final validation. Okay, yeah, after the phases. That's right. Okay, good. And update metadata. Yep, that's right. [music] Report summarized was built per phase. This looks right. Now, we should have a very powerful self-contained skill. I think image generation, [music] we need to be a little bit more clear on to go and search images. We have a really, really long instruction here. Probably want to break instructions [music] into H3s, but this is fine for now. You know, with all the plan, templates, [music] and you know, meta planning skills I create, these are just iterations. I'm going to iterate on this. But, what I want here is a really powerful first version. And I want to >> [music] >> really show and convey how much time I put into a very, very important skill like this. Your planning skill is one of the most important, if not the most important skill that you and your agents will have in contention with the meta skill or meta prompt in the prompt template. Add image slots [music] in the following sections that concisely, yeah. I guess in the following sections that
[00:45:01] represent section. I want an image for problem, solution. We don't need one for purpose, probably. We don't need one for sections. I do want one, one per phase, and optional questions if questionable, and as many as the agent wants inside of notes. And let's expand and really loosen what we're looking for. Let our planning agents [music] run free in the notes section. Yeah, many engineers, maybe yourself is included in this. One of the critiques of this approach of really templating your engineering is the idea that you might be limiting the model and limiting what the model can do with the idea being that it'll generate a better plan than this given that you let it run free. I don't think that's true. I think nine out of 10 times spelling out the exact plan format you want and then creating a section like this for the agent to run free and add all the details it wants is going to be more valuable. Because again, this is not just for your AI agents, it's for you, your team, and your AI agents. So, there's a trifecta of users, of
[00:46:00] consumers of the plans, and it needs to satisfy all three, not just one. [music] This is looking good. Author rich spoke HTML as needed. Very good. Very good. Free form. Nope, that's good. That's good. Including the image block below. So, I think this is good. Let's go ahead and just look at our raw. This is where it all started. Let's see where we're at. So, embedded checklist, validation testing, that's the one last thing we need to make sure is [music] dialed in here. We have that in our build plan. Let's make sure we have this in validation, our output spec here. Loop. Plan is not complete until every box is checked and every command passes. Yeah. If for some reason step is not possible to complete, mark it with F and move on if possible. So, we want to leave some room in for a real failure mode. And again, we're leaning on our model's capability to identify this potential reality where we have a truly blocked section, right? A truly blocked task or phase, which hopefully we won't run into, right? Because we would have thought through that, but let's see. And one more thing I want to do here, add last step to create plan, open in
[00:47:01] [music] IDE, add a variable IDE, code is the default. Static variable. This should sail us right home. And now, if we view this [music] reusable plan, this is a plan template, we should be able to get a good format here. Default false. Okay, there's our table with the file to read. I want to break this into a sub workflow so it's clear. Move into a sub workflow so it's clear. [music] This will be called in other workflows. There we go. That's clearer. [music] And we do need an environment variable file here for our OpenAI key for image generation. And uh that should be it. So, I'm going to close everything. So, now we should have a plan format [music] for Babel 3. We started out with a simple raw write-up of what we want done. We passed it to our agent. Our agent skipped some steps, but it helped us get the job done. [music] We spent a lot of time hands-on on this skill, really using our hands, typing things out, thinking things through, we created a multi-workflow
[00:48:01] skill with of course a couple of scripts to generate images. And now let's kick it off. Let's do something with it. Okay, so if we boot up our pie coding agent, you can see [music] we are reading that new skill in here. And I'm putting this up only to showcase this tool that I have. I've talked about it on the channel before. I have agent-to-agent communication. My agents can prompt each other at a moment's notice. Ping agent seven r9. dot dot on the network. [music] This is built on a simple HTTP server. You can see we're using Minimax 3. It allows my agents to communicate with each other. It's great, it's simple, it's super concise. What [music] I want to do here is play with this new piece of technology, or maybe it's not new. I'm actually not even sure when [music] this was created, but I've been checking this out, having my agents draft and look at this, and it looks pretty good. This is called Iron, and this service enables a direct connection between applications. [music] So, think Tailscale, but for application. So, embedded inside the application, right? You don't need to connect to some server or [music] anything like that. Um, it's got a bunch of nice features, secure, fast, modular, blah blah blah. And the biggest sell
[00:49:00] here for me that I'm interested in is [music] having applications, specifically, as you can imagine, agents being able to talk to each other across these networks, transferring uh large files, documentation, and all types of things across a network very, very quickly using a variety of transports [music] and encryption protocols just to make things more secure and simpler. As I scale up the number of agents I'm using on [music] different devices and in different agent harnesses, this version I have here is fantastic, but it's just the first version, simple HTTP over network. All that to say, I want a V1 of this. I'll skip through this. I'm going to write a simple input prompt. [music] Here we go. So, I have a simple input prompt to this. This is what our agent is going to write the plan against. [music] I pulled in my pie versus cloud code extension, which contains this very pie coding agent extension that I wanted to modify. I have a bunch [music] of requirements here, and then I've listed some documentation. Let's just kick it off, right? Let's see what our brand new spec [music] format comes up with. We are going to kick this off in a Claude code instance running [music] the Opus 4.8 model, not the state of the art
[00:50:01] Fable. I'm hoping that the Fable 5 model is going to be available to you, but I am planning for this to be released. I'm [music] planning to push my plans further with the Mythos class model. So, let's go ahead and [music] just run this on Opus. Opus is going to get us, you know, 80-90% of the way there. So, let's test out our brand new planning prompt. I'm going to write / plan [music] F3, plans for Fable 5, and we're going to run it against this file. So, I'm going to do a little bit of prompt engineering. [music] I'm just going to say cat, paste this in, question mode off. So, I'll just leave this off entirely so that our agent does not kick on our questionable mode, right? This is default false. So, basically, I want no human in the loop here. So, we'll kick that off, and we'll let our agent operate this top to bottom, and there it goes. It's going to understand scale. You can see it's in that create plan workflow. There you go. Now, it's in the image generation workflow. It actually picked up on the other specs that we just wrote. So, I probably should not have had those in there, but that's fine for now. There you go. So, yeah, let's just kind of walk through and see what our plan really feels [music] like to
[00:51:00] create. So, we have the requirements. We're saying, you know, temp directory, use PyCroco for research. It is pulling in the Py versus Claude code base, and this is publicly available, of course, on my GitHub repository. This is a public code base available to anyone, and it contains several PyCodingAgent custom extensions. We covered the PyCodingAgent in the past. Feel free to check this out. Link in the description. There's an extension in here that details exactly how this communication network works via HTTP. And so, what I want to do is have my agent write a brand new plan to build this against the Iron network protocol. Instead of using raw HTTP [music] and a simple server, we're going to write, using our new spec format, a brand new agent-to-agent communication plan using this new tool. So, that's the idea, right? Lightweight modular, networking. I want to re-implement my agent agent network communication using this. So, let's go ahead and see [music] what our agent does here. What I want to show you is the valuable end result of spending time on one of the most important skills [music] you'll create, which is your
[00:52:00] meta planning skill. Okay, so our agent just finished all the research. You can see it's [music] been spinning here for about 6 minutes, and now it's writing out the complete HTML plan. Just to like re-emphasize all the value of investing in your planning meta prompt. The key idea here is HTML gives your agent more tokens. [music] Anthropic put out a great piece on this. The more valuable tokens you give your agents, it gives them a slight edge on producing the result you're looking for. Now, this will use more tokens. As we discussed [music] in our moral write-up, we have a clear set of priorities. Whenever you're sitting down to build both agentic tools and raw engineering tools, product tools, whatever it is, understand your priorities. What are you willing to give up to get the result you're looking for. We are more than able and willing to spend tokens. We're using an HTML format. We're also going to generate images. Images is going to give yourself, your team, a quicker way to ingest the information, ingest the plan, but it's also going to give your agents a way to really understand the image at a deeper level. There's a whole new wave
[00:53:00] of multimodal specs right on the horizon, the agentic horizon, that is going to be available, and these new models can intake that information. And images is just kind of that first version of that where they can intake text, images, [music] and the next two things coming is of course audio and then full-on video. And so, this is going to be valuable, and again, middle-class models will be able to use all these tokens and really deeply [music] understand the problem and the space and your code base, your problems in a better, more efficient way, or a more effective way, not efficient, because they will be chewing up tons of tokens and additional time to do all these things. You can see my agent is working through the HTML [music] tokens now. We are chewing up a ton of tokens to generate HTML, but that is a cost we knew we were going to pay up front, okay? Because we thought this through completely. [music] We had a nice API design, we created specific workflows. We probably could have added more detail here, but the key thing to nail, I think, in any system [music] you're building is the properties. What do you want this thing to do? What's the
[00:54:01] advantage that each one of these things brings to your system? And so, we kind of wrote that out here to make sure that everything was clear. We're going to see the true results as this file comes out. There we go. Generate eight files in parallel. I'm glad it picked up on parallel. I don't know if we ever mentioned that anywhere. So, that's just the model being great. Let me see if we Yeah, we don't have a parallel keyword at all. So, parallelize the image generation as there's no reason to block here. Great. All images in parallel. So, hopefully this is actually in parallel. That's running in the background. Generate hero. Okay. No, that is That is working. That's good. I'm expecting this bash tool to stack up, and I'm not seeing that. So, I'm just curious if this is actually in parallel. You can also say in parallel stack up the bash protocol if you aren't already. I'll hit that, and then I'll kick this off in the background. Okay. Wow, I feel like that GPT image two generator got faster. That's way faster than before. Maybe those did not generate with a high-quality setting. We'll see. Generate [music] Yeah, we might be getting some low-quality images there. We'll see. Update to generate in wide
[00:55:02] format. Wide format always [music] in high quality. See two of files for info. Okay. Here we have our full HTML file. So, let's go ahead and see. We want this to open up in Chrome since this is going to be HTML. So, let's go ahead and document this as well. Update [music] our final step from create plan. We want this opened in browser. New variable, default Chrome. >> [music] >> I know some engineers are super against Chrome cuz they're gobbling all the data and all the memory. That's totally cool. Use whatever you want. But let's go ahead and see what we have. So, open in Chrome. >> [music] >> And let's see what our new Mythos class level planning tool has gotten us here. A couple things right away. We have a clear one-shot hero image. We have our header line purpose here. We have our metadata, which can be easily tracked. You can see there's all the back references. We have this MD file, which back reps, I guess that was just created. We have this, our public code base repository with the references there. We have the session ID, we have
[00:56:00] the agent name, [music] which we just put cloud code there. It could be doing a little more detailed. Commits modified and created. You can see the current date there. And then we have our hero. So, this looks great. And then we have our purpose. So, reporting this looks fantastic. That's exactly what we want to do. Also, our requirement, one step, one-time configuration. So, it really paid attention to this detail. That's great. As the models get better, like the key details you add to every plan is going to be emphasized even further. Let's see here. Here's the problem. Exactly, button holds everything. Server sent API. Yep, must be told where the hub is. Exactly, bunch of configuration there. You can see single point of failure. Yes, yes, yes, bound to one host. Exactly. It's It's actually explaining every problem with the current situation. And yeah, this is the exact setup for that current solution. And then here's the new solution. Replace central hub with an iron gossip swarm. Not sure what that is, but [music] we can see exactly what this looks like. This is our peer-to-peer network. And apparently, this lets us get away with a single environment variable. Love to see that. One-time config. Topic identity. I'm not going to go through this right now, but I'm
[00:57:01] curious about this implementation. Might throw this back at the code base and see what we get out. Create HTML relevant files, new files for that agent that's going to build against this. Implementation phase, execute every phase top to bottom. And this is really great. Every phase of this work has a single image to convey the information. So, foundation, iron gossip proof of concept. Great. You can see all the tasks, [music] individual tasks, very clearly. We have our closed-loop prompt. Do not exit this phase until every box above is checked. Uh, [music] if the POC cannot round trip, you know, complete that work. So, we have testing phase, two-node gossip, static resource primitives. We're really detailing everything we want done in this phase of work. Love that. Phase two, we have a nice sidecar, looks great. Phase three, again, just like HTML is great. As you can see here, right? Give your agent more useful tokens, and it will be easier to read, easier to update, and easier for other agents, your team, and you to consume. Images takes us to a whole 'nother level. We have to give huge credit to OpenAI's ChatGPT image two because the image fidelity and the instruction following is off the charts.
[00:58:01] There's a reason this is still the best image generation model. I'm really excited for the next image gen model based on the work they've done here. But, here's our per phase imagery. Phase four, this is parity verification and resilience and docs. Love to see this. Oh, we have a parity matrix document below. If we click this, we can scroll down to it in the note section. So, super, super important to give your agent room to run because a lot of great engineers, to be more specific, a lot of great agentic engineers moving at light speed, aka the agentic speed, would look at my plan template here, and they would say something very logical that I would understand. You are constricting the agent's ability to plan what they need to plan. That is true unless you do something like this, and you add a note section. Let [music] the agent say what it needs to say. Here, you can see it added a feature parity matrix between the original pod-to-pod agent communication framework we built out. I'll link that video in the description if you're interested. And this new iron version. Okay, so, really, really good stuff here. It also generated an image of exactly how this is going to work. It has some reference documentation, some
[00:59:00] dependency [music] docs, and then the amendment section for April coming to the plan after it's built and want to make some changes. So, this worked out fantastically. Of [music] course, I'm going to run an experiment on these other workflows. So, this planning document format is very, very powerful. Once again, I've templated my engineering. I'm forcing the agent to perform very well, state the problem, state the solution, break this up into all relevant files, identify all the files, existing and new, break it down into an implementation [music] phase, execute phase, and tasks top to bottom. You can see this is what we wrote, and then this was the templated portion for the agent to fill out. We are templating our engineering. Okay, [music] this is a key idea inside of tactical agent decoding that really holds up for all agentic engineering work, and it's what gives you your differentiated results, skills, and as you can see here, plans. Really really great stuff. Just to kind of jump back to the core of this, this is running on Opus. Opus is a great model. It's going to give us 80-90% of what Fable 5 and Mythos class models can do, but then there's going to be a point
[01:00:01] where it cannot do [music] what these models can do. You can imagine if you run this, which I'm going to make this new plan F3 skill available to you, link in the description, you can imagine if you run this on Fable, on whatever's coming next, the results are going to be really really cracked. I'll just leave it there. There are a bunch of improvements on top of this that can be made to this prompt. You know, one thing I want to add right away is SVG [music] support for some of the more dynamic node-based diagrams. You don't always need an image. An [music] image just takes up more time and tokens to update. There are a couple other directions to go with this, but the core value is here and ready for the next generation of Mythos class models. You know, I see a lot of hand-waving, a lot of vibe coding going on in the industry. [music] Engineers are not typing, they're not thinking anymore, they're just mindlessly prompting their agents. I can almost promise you that's going to lead to worse results over time. We stopped coding a long time ago. I stopped coding even before Cloud Code came out. Not many people are going to believe that. Um I was using a tool called Aider, and you know, I was outsourcing a lot of my
[01:01:00] raw hands-on typing [music] work. This has progressed, and a lot of us are becoming skill atrophied. This is natural. [music] This is okay. All great technology gives and takes. And as these models continue to progress, that will continue. But you do not want to outsource [music] your thinking. You do not want to outsource your thoughts. You want to be able to continue to plan work, think through exactly what you want to see because great planning is great engineering. [music] That's the one-liner, the one idea I want to leave you here with. Link in the description for my updated [music] plan F3 plans for Fable 5 skill. Just take this as a single sign, a single signal that you use to build an agentic engineer for your company, for your work, for your [music] career. Feel free to comment down below. Let me know how you're preparing and changing your agentic engineering for the next class of mythos level [music] models. I'm hyper focused on the planning and review constraints. To me, these seem like the greatest places to spend time to increase our ability to move at the agentic [music] [01:02:01] speed while building out very, very valuable, very hand-picked, hand-structured, [music] heavily engineered foundations and fabrics and meta skills and meta prompts for our agents to use. You want to get out of the normal distribution of results by teaching your agent how you engineer by templating your engineering. It is your specific domain knowledge and expertise that differentiates you. So, you want to encode that into your work. You can see here, I'm doing it inside of the skill. This is just one example of how you can do that. If you made it to the end, definitely drop a like, drop a comment. Huge thanks to you. You know where to find me every single week with hands-on agentic engineering content like this. Stay focused and keep building.