YT YouTube2Text

YouTube2Text → Transcripts → My Super Simple Software Factory (For Agentic Engineers)

My Super Simple Software Factory (For Agentic Engineers) — Transcript

by IndyDevDan · 6,606 words · 966 segments · language en · Watch on YouTube

Open in transcriber Summarize with AI Download SRT/VTT

Full transcript

0:00What's up engineers? Any Dev Dan here.
0:02If you're building systems of agents
0:04that operate for you, stick around. This
0:06is going to be a valuable one for you.
0:08If you're mindlessly vibe coding slop,
0:10this video is not for you. Click away.
0:13Thanks. See you next time. Software
0:14factories are massively misunderstood
0:17and under appreciated. The key is to
0:19understand that they're useful for one
0:21reason alone. They give you more
0:23leverage on your prompt. That's it. Now,
0:26the amount of leverage you can get is
0:28determined by the quality of your
0:30investment into your software factory.
0:32At the lowest levels, you chain together
0:34a few agents to do a little more work
0:36for you with some minor configuration.
0:38At the highest levels, you build a
0:39system of agents plus code that operates
0:43without you just as well and sometimes
0:46even better than you would. In this
0:48video, I'll share my super simple
0:50software factory to show you how you can
0:53begin to unlock this [music] leverage.
0:55This factory is a combination of the big
0:57ideas we've discussed on the channel and
0:59inside TAC, [music] except it's been
1:01rebuilt from the ground up for the next
1:04phase of agentic engineering. If you
1:07understand [music] that agents plus code
1:09beats agents alone, and if you want
1:11another edge in the age of agents, stick
1:14around and let's break [music] down the
1:16super simple software factory.
1:23There are three key design principles
1:25I've embedded in the super simple
1:27software factory. It's observable, it's
1:29customizable, and it's reusable. All
1:31things that are essential to operating
1:33in the age of agents. Observability is
1:35key. If you can't measure your agents,
1:37you can't improve them. We can click
1:39into any AI developer workflow here and
1:41see exactly what happened in a swim lane
1:43view. We have Kimmy K3, Gemini 3.6
1:46Flash, GPT 5.6 Terra, GPT 5.6 Luna. We
1:49have an abundance of great models to
1:51work with at different performance speed
1:53cost tradeoff points. And your software
1:55factory lets you use all of them
1:57together. The best engineers now are
1:59building systems of agents. They're not
2:00debating which model is the best
2:02anymore. It's important, but it's less
2:04relevant every single day. Software
2:06factories are the system you use to
2:08scale your compute, to scale your
2:09impact. I've denoted the three actors of
2:12value creation. There's me, the
2:14engineer, there's the code that actually
2:16executes, and then we have our agent.
2:18So, this isn't just about running a
2:20bunch of agents in parallel or in
2:22different team configurations. It's
2:24about combining engineers plus code plus
2:26agents at the right time to get the best
2:29results. Agents plus code beats agents
2:32alone. We'll talk about that more later
2:34on in this video. We can dial into
2:35anything here. Let's check out kmk3's
2:37plan. Of course, you can see all the
2:38events, and we can see all the
2:40configuration. We can see the compiled
2:41prompts. So, of course, both the system
2:43prompt and the user prompt. Your
2:45software factory depends on your ability
2:47to prompt engineer, context engineer,
2:49and of course, harness engineer. We can
2:51go up to the agent config. You can see
2:53all the tools. You can see the coding
2:55agent we use, and you can see the
2:56specific agent harness we used. This is
2:58very powerful. This software factory is
3:00allowing me to do all the
3:02sub-engineering inside of agentic
3:04engineering. So, I'm talking about
3:05prompt engineering, context engineering,
3:07harness engineering, and what's
3:08inaccurately called loop engineering,
3:10which is really all about managing the
3:12software developer life cycle inside
3:14your work. Check out the previous video
3:15where we dismantle loop engineering.
3:17It's a terrible rebrand of the software
3:19developer life cycle. I'll link that in
3:20the description for you. But, let's
3:21actually run our super simple software
3:23factory. What does this actually look
3:24like to execute? Let's open up the
3:26terminal. I'm using Herder as my
3:28terminal multiplexer now. I've
3:30transitioned away from tmux. Great tool,
3:32but Herder gives me everything I need
3:34and a little more. It's more
3:35customizable. It's more configurable.
3:37It's simpler, and it's faster. I'm going
3:38to fire up a Pi coding agent. We're
3:40going to run the new cracked
3:42state-of-the-art Opus 5 model here. So,
3:44a key feature of the super simple
3:46software factory is that it has agentic
3:49access. That means we can move at the
3:50agentic speed. I have engineered the
3:52system to be operated by, of course, us.
3:55So, if we wanted to, we could boot up
3:56just commands and we could operate this
3:58ourselves, right? You can see we have
4:00the plan workflow, plan build, so on and
4:02so forth. But, why would we do that when
4:03we can move at the agentic speed and
4:05have an agent orchestrate the system on
4:08our behalf? Let's kick off a workflow.
4:10We'll run this prompt, break down what
4:11this app is, its features, and suggest
4:13three new features to enhance the
4:14application. And now our agent is going
4:16to get to work understanding lazy
4:18loading the remainder of the skills it
4:21needs to actually operate this. We're
4:22using Opus 5, so you can see it's ultra
4:24smart. It's going to write this prompt
4:25and it's going to kick off this
4:26workflow. I'm going to open up the tool
4:28in the background here and you can see
4:29it's already started to get to work. So,
4:31this is observable in a live way. So,
4:33you can see we're running a simple ADW
4:36scout workflow. We're going to start
4:37simple and progress to a more complex
4:40prompt, more complex AI developer
4:42workflow inside our software factory.
4:44We're running a single scout agent. We
4:45can dial into the request. We can see
4:47what we, the engineer, inputted into the
4:49system through our agent. It has
4:51enhanced my prompt to make it even
4:53clearer, more concise. And of course, I
4:55prompt engineered that into the super
4:57simple software factory. And now our
4:59scouter agent is just running and it's
5:00going to report its results. So, we have
5:02a simple two-phase workflow here. The
5:04request comes in and then we have a
5:05scouter agent. One engineer, one agent.
5:08Super simple. We're running the Gemini
5:093.6 flash model, which is a really,
5:11really cost-effective model. If we open
5:13up my model stack here, which is where
5:15I'm tracking all the models, state of
5:17the art, we have workhorse and then we
5:18have lightweight models that run on your
5:19device. Gemini 3.6 flash is our A-tier
5:22workhorse model at really cheap prices.
5:24You can see here this thing operates at
5:26$1.50 in, which is beating out pretty
5:28much every model above it, minus Luna.
5:31Luna is also another great option from
5:32OpenAI. But, you can see here, I'm not
5:34really fixating on one model anymore.
5:36I'm using the right model at the right
5:38cost, at the right speed, at the right
5:39price, at the right performance. It's
5:41about your model stack now. And again,
5:43the software factory is how you get to
5:45that. Let's go ahead and open up our
5:46agent and you can see it has the results
5:48from our workflow. So, an AI developer
5:51ran, which is an AI developer workflow,
5:53all it did was scout the application.
5:55So, this is a really, really simple
5:57atomic unit of the software factory.
6:00Just scouting, just looking for code,
6:02finding information, presenting ideas.
6:05So, that prompt was really simple. Break
6:06down the application, suggest three new
6:08features, and then we have a definition
6:10of done. So, that's exactly what my
6:11agent did. So, super simple. You can see
6:13here we have three proposed features.
6:15see that we are building an application
6:16called Inkwell, where we can basically
6:19just do some writing. So, this is what
6:20it looks like. It's a super simple app
6:22I'm using as a test, as a prototype to
6:24enhance and to build the super simple
6:25software factory. We have some nice hot
6:27keys. We can go into focus mode. We can
6:29zoom in. We can zoom out. And we can
6:30create new ideas here whenever we want
6:32to. Let's go ahead and run a more
6:34advanced AI developer workflow inside of
6:36our software factory. I want to really
6:38show you how powerful this tool can be.
6:40If we scroll back up here, I've prompt
6:41engineered this orchestrator agent to
6:43present all the workflows this software
6:45factory has. So, you can see everything
6:47you would expect. The simple prompt, a
6:48scout, a plan, a build, quality check,
6:51so running our lints, running our
6:52formats, our type checks, documentation,
6:55and then the composite workflows, the
6:57heavy hitters, the workflows that really
6:59do the work on your behalf. So, you can
7:01see plan, build, test, build, review,
7:03build, test. And then of course, ADW
7:05simple software developer life cycle,
7:07the full deal. Okay, so we're going to
7:09work up to this. Let's go ahead and run
7:10an intermediate step. If you're a
7:11technical agentic coding member, this
7:13all looks very familiar to you. You've
7:16likely mastered these ideas already.
7:17Let's go ahead and kick off a new
7:19workflow. And I want a classic light
7:22mode. So, I'm just going to paste this
7:23in. I'm going to run the ADW plan,
7:24build, test. Add light mode to contrast
7:26with dark default. Build a design system
7:28such that we can add other themes in the
7:30future if we want. So, we'll kick that
7:31off. And now we're going to get a
7:32three-step agentic workflow that
7:34combines code and agents. And so, we'll
7:37break down the internals of this
7:38application a little more in a second,
7:40but we can go ahead and see in our
7:41observability system this new workflow
7:44running. So, now we have a planner and a
7:45builder. You can see here we're going to
7:46use the ChemK 3. It's a pretty good
7:48model. It's definitely not outperforming
7:51Opus 4.8, Soul, any of the really big
7:53heavy hitters, but it is the first open
7:55weights model inside of the
7:56state-of-the-art tier, which is an
7:57impressive feat. You know, something
7:59I've noticed that you likely have too.
8:00This model thinks a lot, so it's not
8:02actually as fast or as performant as
8:05Opus or Soul, but it's still an
8:06incredible model. I've been using this
8:08model through Fireworks. I've been
8:10really enjoying using Fireworks, using
8:12ChemK 3 on it. They have put out some
8:13really great endpoints. They have a fast
8:16and a priority serverless tier, US only
8:18serverless endpoints, one of the first
8:20to do this, I think. You know, last week
8:22we talked about this idea, is Anthropic
8:24stealing your data while you pay for it?
8:26And we really answered that question in
8:27depth. Check out that video, I'll link
8:28that in description if you're
8:29interested, but Fireworks is responding
8:31to this very idea of AI ownership. I'm
8:34not sponsored, I don't take on any
8:36sponsorships. They're really addressing
8:37the need for AI model ownership and for
8:41just cheap serverless inference with
8:43great optionality without taking all
8:45your data. Let's see how our software
8:46developer life cycle is doing. So, you
8:47can see here we have two agents that
8:49completed this workflow. Okay, so we're
8:51adding light mode to contrast the
8:53default dark mode. So, let's see first
8:54off, did our agents build the work? You
8:56can imagine they did. So, here we have a
8:57light button, we can click it and the
8:59color inverted. Fantastic. So, how do we
9:01do that? We built a simple software
9:03factory that contains a workflow that
9:05plans work and builds work, and then we
9:07have, you can see here, two code checks
9:09that occurred afterward to verify. And
9:11you can imagine if these verifications
9:13fail, they'll send that work back to the
9:15build agent and the build agent will
9:16correct the mistakes. Okay? So, simple
9:18enough feature. We didn't need a huge
9:20workflow for this. We used ChemK 3 just
9:22to plan and we used Gemini 3 Flash to
9:24actually build out what was implemented
9:26in the plan. So, just chain together
9:28some agents while understanding that all
9:30this doesn't need to be agentic. This is
9:33like a really big idea that I think
9:34engineers are going to miss and miss
9:36pretty seriously. Right now everyone is
9:38like very agent pilled. I think that's
9:41very cool.
9:43You know, I get it. I definitely
9:44understand that. But everyone in their
9:46AI psychosis has seemed to have gotten
9:48that code cost nothing, literally runs
9:51at the speed of light, and can be
9:52changed in instant. And a big thing
9:54people are re-realizing now is that you
9:56actually own your code. Whereas we don't
9:58actually own any of our AI models. We're
10:01renting them. Code is an essential piece
10:03for this. You can see I've designed it
10:04inside the workflow and I'm treating it
10:06as a first-class citizen here in the
10:08software factory. I recommend you do the
10:10same. By the way, I'm not trying to sell
10:11you my tool. This is going to be free
10:12for you. Link in the description. This
10:14is open-source software I'm building and
10:16sharing. I want to paint the picture
10:17where things are going because it's not
10:19just about your single agent. It's not
10:20just about your multi-agent
10:22orchestration, your orchestrator. Things
10:24have scaled quite a bit far beyond that
10:26and they've scaled into these software
10:28factories. I'm seeing it in the field.
10:30I'm seeing it in my discussion with
10:31engineers and in my own work, what I sit
10:34down to build now, I'm not thinking at
10:36the prompt level anymore. I'm not
10:38thinking at the skill level. I'm not
10:39even thinking about the teams of agents
10:41I need, which is super important. I'm
10:43thinking about the full end-to-end
10:45developer workflow that I would run to
10:48get the work done and then I'm building
10:50that with agents. It's an AI developer
10:52workflow. And this way I can reproduce
10:54the success I want to see in my
10:56applications over and over and over. The
10:59system is built to be reusable,
11:00observable, and customizable. Let's talk
11:02more about customizability and
11:04reusability. Cuz you can see here full
11:06observability. This isn't new.
11:07Everyone's got their agent framework
11:08that they use to view what's done. But
11:10let's go ahead and just like look at the
11:11plan. So what happened here? Planning
11:13work happened. It has its own detailed
11:15system prompt and a user prompt. We can
11:16dial into the agent config. But the
11:18interesting part here is we're making
11:20sure that work was accomplished by
11:22adding deterministic gate checks. So
11:24this is code, right? Let's be super
11:26clear about this. This is code that runs
11:27at the end of the plan step. And then we
11:29have, of course, a nice cost breakdown
11:31for this individual agent phase
11:32execution. And then we have the outputs.
11:35So, we're handing off contexts by
11:37creating a shared directory here. You
11:39can see ADW sessions, and we'll look at
11:41the code in a second here if you're
11:42interested. I am, by the way, still
11:44reading the kind of essential pieces of
11:47my code base. It's not all of the code,
11:48but the essential pieces. You definitely
11:51want to read, especially when you're
11:52going to be rerunning the code over and
11:54over and over. Basically, like the more
11:55you're going to productionize something,
11:56the more you should dig in and
11:57understand what's happening. So, you can
11:59see here, we have a nice handoff.
12:00There's the plan, created some theme
12:01tokens, and then this agent has left a
12:03note for the next agent. Kind of a nice
12:05way to hand off things. But, this is a
12:07deterministic type. So, my agents are
12:09outputting JSON, it's getting formatted,
12:10it's getting validated. If it fails, the
12:12agent must properly output it, okay?
12:14Determinism is wired into every one of
12:17my agent steps. They must output
12:18specific types, specific structures. I'm
12:20looking for consistency in my AI
12:23developer workflows, in my combination
12:25of agents plus code. I'm not doing
12:27one-off work here. I need these systems
12:28to work reliably over hundreds and
12:30thousands of executions without me. And
12:32that's the key we're moving toward here.
12:34The software factory lets your agents
12:36run, if you do it well, without you.
12:38That's the key. And then we have the
12:39build step. Guess what the build step
12:40does? We can go into the compile
12:41prompts, go into the user prompt build
12:43task. There's the actual prompt, and
12:45here's the previous envelope. This is
12:47the work that was handed off from the
12:48planner. So, it has all the context it
12:50needs, it has the task, it has its
12:52response report format. If you've been
12:54with the channel, you understand this
12:56prompt format very well. Instructions,
12:58variables, workflow report. itself,
13:01again, keeps chaining its output to the
13:03next agent or to whatever agent's coming
13:04next. Changed files, just tracking what
13:06you would want to track in a build
13:08agent. Of course, we can see all the
13:09tool calls, and we can really understand
13:11the system. If you don't measure it, you
13:13cannot improve it. That's the super
13:14simple software factory. It is quite
13:16simple. I'm making a couple key moves
13:18here. I'm making sure that we directly
13:20address engineer work incoming prompts.
13:22I'm making sure that we address our code
13:24directly. And then, of course, we can
13:26customize the agent as much as we need
13:28to to get the work done. So again, code
13:30plus agents beats agents alone. A lot of
13:32engineers are just going to start
13:33throwing everything into skills,
13:35everything into a bunch of agents. Down
13:37the road you will pay for it. You'll pay
13:38for it in some way, whether it's
13:40mistakes, hallucinations, which I know
13:42is becoming less and less of an issue as
13:44these models progress. It's not just
13:45that, right? There is cost, there is
13:47speed, there is performance. There are
13:49just things you likely are having your
13:51agents do like execute tests that you
13:53could run into deterministic paths of
13:55code and then if something goes wrong,
13:57hand it back to your agent. Tell me why
13:58you would need to pass successful
14:00passing tests back into your agent's
14:02context window. Again, this is just one
14:04more advantage you get by understanding
14:06what's actually going on. And again,
14:08that's that fine line between vibe
14:09coding and agentic engineering. Let's
14:11scale this up. Let's do something more
14:13interesting. I want to dive into how
14:15this tool is customizable and
14:16configurable and now I'm going to be
14:18using this tool for my products, for my
14:20code bases. We're going to run the full
14:21software developer life cycle. You know,
14:22you can imagine I've invested more time
14:24into this AI developer workflow. We're
14:26going to give the Inkoo editor a
14:27side-by-side markdown viewer. In the app
14:29right now, there's no actual markdown
14:31render. We would love to have this for
14:33writing. You need to emphasize things,
14:34you need to underscore things, blah blah
14:35blah. Let's go ahead and get this added.
14:37Just kind of detailing that we want a
14:38switcher, cover it with tests,
14:40togglable. And then we have this
14:41additional instruction here. Use the
14:43state-of-the-art configuration for this
14:45work. So of course, with the system we
14:47can customize every single model, every
14:49single role, every single agent harness,
14:51every single tool, so on and so forth.
14:53We'll just go ahead and watch our agent
14:54boot this up so you can see us doing a
14:55little bit of research, understand the
14:57system, AWS DLC. There's a frontier
15:00config we'll look at in just a second.
15:01Confirm the roster and now it's going to
15:04get this kicked off with the SDLC and
15:07that prompt that we're running. So
15:09that's that. Now we can go back into our
15:10observability system and we can see this
15:12running. Simple SDLC. And of course, as
15:14our planner, we have the cracked Claude
15:16Opus 5. Shout out to Anthropic for
15:18putting out another game breaking model.
15:20It's state-of-the-art. The one thing I
15:21will say is it's reportedly above Fable
15:245. I'm not quite feeling that and maybe
15:27I'm just getting cost baited here, but I
15:28still feel like Fable 5 is above Opus 5.
15:30Comment down below, let me know what you
15:32think. Does Opus 5 clear Fable 5? I
15:34don't think so. Regardless, they're all
15:36kind of in this same frontier level
15:39model now and so I'm really impressed
15:40with that. Really a great model and you
15:42know, the fact that it's half the price
15:43obviously makes it the model of choice
15:45over Fable 5. I'm just still using Fable
15:475 when I can here in the really, really
15:48critical situations just cuz I think
15:50it's still a notch above and I've seen
15:52all the benchmarks. I know that the
15:54benchmarks are saying Opus 5 beats
15:55Fable. It's just what I'm feeling with
15:56my benchmarks and my execution. So here
15:58we go. We're running state-of-the-art
15:59workflow here. We want to give our
16:00Inkwell editor application a markdown
16:02side-by-side view. You know exactly
16:04what's going to happen here. We're going
16:04to run a full software developer life
16:06cycle. Let me go ahead and show you some
16:08of the underneath, some of the
16:09nitty-gritty of this, right? It's
16:10important to understand how your system
16:12works so you can improve it properly.
16:14Let's go ahead and jump into this a
16:15little bit. I'm going to open up the
16:16code base here. For code viewing, I am
16:18using VS Code. There isn't really any
16:21reason to use anything else right now
16:22and it's really just for code viewing
16:24and I do do some typing when I'm writing
16:25out my prompts inside of VS Code. So all
16:28of this is wrapped around a single
16:30skill, SSSF, Super Simple Software
16:33Factory. The whole idea with this
16:34application is that you can build these
16:37workflows where you have agents
16:39proposing and code disposing, right?
16:40Your code is always validating what just
16:43happened. It's always doing the
16:44deterministic things and the code
16:46actually controls the entire workflow.
16:48If you've taken Tactical Agent Coding,
16:50this is going to look very familiar to
16:51you. We have an ADWS directory inside
16:54this code base that contains our AI
16:56developer workflows that run end-to-end.
16:58This workflow that's running right now
17:00is the largest workflow we have here. We
17:02have the simple SDLC here at the bottom
17:04and it's relatively concise, right? It's
17:07180 lines and I know like everyone's
17:09shocked right now and you can't bear the
17:10sight of looking at code. Yes, I do
17:12actually still look at the critical code
17:14in the main line of my code to make sure
17:16it is going to scale and to make sure
17:19that my agents can operate it properly,
17:21right? Yes, I coordinated it with agents
17:23to build this out. But, you can see here
17:24we have phases. So, we're using the
17:25width statement in Python to denote the
17:28entrance and the exit of this block of
17:30code. And this is what makes up the
17:31individual piece of work that we want to
17:33do. We have planning here. We just
17:34search for name. We have our requests,
17:36which is our engineer type. We have our
17:38plan. We have the commit plan, build,
17:40test. If something goes wrong, fix.
17:42Something goes wrong, review, revise.
17:44Again, if something goes wrong, document
17:46and our commit docs. So, we are clearly
17:48separating agents plus code. And we can
17:50do this by looking at this. We go kind
17:52equals. And so, you can see how we are
17:54separating this out. Let me go ahead and
17:55just get rid of this. Search, engineer,
17:57agents, code. And so, we're clearly
17:58delineating this for ourselves and for
18:01our agents. Every one of these is an
18:02agent call to my favorite agent to
18:04coding tool. If you go into AGW modules,
18:07I am running the pie coding agent. I've
18:08got it all configured here. And at the
18:11end, it's just going to run a pie coding
18:12agent with all the customization. But,
18:14let's simplify this and just look at the
18:15configuration. So, super simple config.
18:18And this is what really lets us
18:19customize our agents and their core
18:21four. Context model prompt tools. Always
18:23the same thing. If you match the core
18:25four, you'll master the agent. If we
18:26look at our planner, you can see here in
18:28the base config, we're running that Chem
18:30E K3 through fireworks, thinking high,
18:32nice purpose. We have our prompt
18:34engineering section. So, the system and
18:36user prompt. And then we have the
18:37harness engineering. On the channel,
18:39we've been breaking down, looking at
18:41different types of pie coding agent,
18:43custom agent harnesses. We've been
18:45building them and we've been sharing
18:46them. Mostly in public, some private or
18:48tactical agent to coding and agenda
18:50horizon members. But, ultimately, what
18:52we're doing here is putting together, as
18:54mentioned, the core four for every
18:55specific agent we want to run throughout
18:57the software developer life cycle. So,
18:59this pattern repeats. Here's the
19:00builder. Same thing. Specify the tools,
19:02specify the prompts, specify how your
19:05agent is going to operate. Specialize
19:07it. We've been talking about building
19:08custom agent harnesses. We're doing that
19:10because every single agent can have
19:12their own unique agent harness with
19:13specific abilities, all right? So, you
19:15can see here, I've added sub-agent
19:17support to the planner, and I've also
19:19added it somewhere down here for the
19:20scouter. So, if it needs to, it can spin
19:22up its own sub-agents. Just one simple
19:24example of how you can build out and
19:26specialize the agent harness that your
19:28individual agent executes. The
19:30implications of this are massive. One of
19:32these agent harnesses, as we've talked
19:34about on the channel, can do
19:35extraordinary things. So, that's the
19:37configuration file. The system reads
19:38this in. Where the real magic is is
19:40inside combining this with the actual
19:43ADW that runs, right? So, let's go to
19:44the simplest possible ADW, right?
19:46Prompt. All this does is taking some
19:47inputs, and it runs and executes the
19:50actual agent. We have our pH call. It's
19:53an agents call, and if we search our
19:55phase here, it should be a class that we
19:57can look at here. It's going to just do
19:58validation for us, and then it boils
20:00down into an agent run call. So, if you
20:02look at our call, our agent is going to
20:04then start executing, and this does
20:06exactly what you think it does. This is
20:07going to run right down into our agent
20:10pi and run the run workflow. We can just
20:12collapse everything to take a quick look
20:14at this. There's run, so on and so
20:15forth. And you can see there, we're
20:16setting up the pi coding agent with our
20:18exact params, mode, JSON, provider, blah
20:21blah blah blah blah. No need to overfix
20:22it on the code. Just wanted to kind of
20:23share that. What we're doing here is
20:25really simple. We're staying in
20:27distribution. What does that mean? I'm
20:28not inventing a DSL. The only customized
20:31thing I have here is this config file,
20:32which is just YAML. With the super
20:34simple software factory, we're just
20:35staying in distribution of what these
20:37models know, what they're trained on.
20:39It's just Python. It's just YAML. It's
20:42just agents. And it's just a skill.
20:44Let's go and check on our workflow.
20:45There we go. All finished. Here's that
20:47like high-level view. Here's what it all
20:49looks like put together. And so, you can
20:50see how this could be really, really
20:51valuable. First off, full model
20:53customization. We can put whatever we
20:54want wherever we want it. We have a
20:56great cost analysis. We know how much
20:58some of our work costs. Full agent
21:00configuration. And then we have phased
21:02work. It's plan, build, review. One
21:04agent, one prompt, one purpose. We're
21:06keeping everything nice and focused. If
21:08we need to, we can restart the workflow
21:10with the session ID, with the ADW ID.
21:13Communicating this idea is going to
21:15differentiate your engineering from the
21:16rest of the pack. It's not just agents
21:18here. We have deterministic checks to
21:20validate the work and proceed from
21:22there. There's a lot missing from this.
21:23There's a lot you can do with this. For
21:24instance, I'm just running this on the
21:26main branch. Of course, you're going to
21:27want a branch. You're going to want to
21:29put your agent in a sandbox. You're
21:30going to want to isolate the agent run,
21:33and then there's going to be a merge
21:34step later on. The whole point here is
21:35that this is an observable,
21:37customizable, reusable system that we
21:39can modify at the speed of agents, at
21:42the agentic speed. We can just dial into
21:44this. This is just committing the plan.
21:46Very simple. Here, we're actually
21:47running the test suite right after the
21:49agent is building. So, if something goes
21:51wrong, we feed it right back into the
21:52agent, right? No problems though. So,
21:54then we go on to the review step. So,
21:56what's the review doing? Our review
21:57agent is asking the question, is what we
21:59built what we asked for? You can see our
22:01configuration, classic cracked Opus
22:03model. Everything's looking good there.
22:05So, then we continue to committing, and
22:07then we diff the changes. Why did we
22:09diff the changes? Because we're
22:10documenting the work done for the next
22:12engineer, and more likely the next set
22:14of agents coming into this work. And so,
22:16you can see, it's very concise. It's
22:18doing a streamlined set of things, and
22:20this gives us extreme flexibility. We're
22:22not just throwing a state-of-the-art
22:23model. We're not just torching tokens.
22:25We're not just token maxing. We're
22:26thinking about what our system needs to
22:28win over and over and over, hundreds and
22:30thousands of runs. This is the art and
22:32science of agentic engineering. It's not
22:35just about the one thing you're doing
22:36right now. It's about the hundredth
22:38time. It's about the thousandth time,
22:40and it's about scaling your compute to
22:41scale your impact in a way that is high
22:44leveraged, in a way that gives you
22:46flexibility, optionality, extensibility.
22:48And so, that's the core idea here. It's
22:50super simple.
22:51Literally called the super simple
22:52software factory. For context, I needed
22:55to kind of rebuild a reusable system for
22:58building agent available workflows for
23:00my work coming up here for the next
23:02phase of agentic engineering. It's very,
23:04very clear that there's a new cohort of
23:07engineers that are just building these
23:08now. It's stacking up code plus agents,
23:10and then when you need to human in the
23:12loop, there's many next directions to
23:14take that. Maybe that's a great place
23:15for us to go next. Like, where does this
23:17go from here? This system was designed
23:18to be fully customizable at the atomic
23:21level. Let's first validate that that
23:22feature was built out. Let's go ahead
23:23and refresh this. Let me go and get that
23:25split view. There's our preview. You can
23:27see there's that line there. Let me try
23:29an underscore here. Okay, very good.
23:30Let's try a bullet point. Low. Another
23:32bullet. Great. Let's try a list. Here's
23:34a list item. Great. Let's try a header.
23:37H2 item. Very good. You can see that
23:39this is working pretty expected out of
23:41these models. You can go into full
23:42preview mode and just view it here.
23:43Edit, split, so on and so forth. That's
23:45working very well. Again, SDLC kind of
23:47built this out, validated. These models
23:49are more than good enough to prompt
23:50this. In fact, this is something, again,
23:52you probably could have just thrown in a
23:53single agent and got the work done. I
23:54fully acknowledge that. I know a lot of
23:56engineers watching this is just going to
23:57be like, at what scale do you need
23:59something like this? This probably isn't
24:00the scale. We're getting close, but this
24:02will absolutely save you time at some
24:04point. Cuz at some point your system
24:05will get so large, so complex, that
24:07validation will be the only way forward.
24:09And whether you hand that to an agent,
24:11it's going to be more expensive across
24:13some dimension, likely time or cost, you
24:15will pay that cost. Meanwhile, myself
24:17and other engineers are going to be
24:19scaling the compute to scale their
24:20impact in a high leverage way by
24:22combining engineers, agents, and code,
24:25specifically code plus agents. I can
24:27already see the comments
24:29>> [laughter]
24:29>> in the comment section. Please think a
24:31little further than that. Think about
24:32scale. Think about production. Think
24:34about standards. Think about the
24:36thousandth run, not the first, not the
24:39tenth. So, you know, like, where can we
24:40take this system next? What comes next
24:42in a system like this? So, this super
24:43simple software factory is designed to
24:45be an atomic tool. Everything is
24:47composable, and I've taught an agent
24:49exactly how to operate this. So, how is
24:51this tool so extensible and reusable?
24:54So, Ducklog skills SSF. What I've
24:57actually here is a skill that allows an
25:00agent to operate this system. And what
25:03I've built here is a skill that allows
25:05this software factory to be built into
25:07new code bases. There's going to be a
25:08link in the description. You can clone
25:10this code base, and and then you can run
25:12the {slash} install command. And so,
25:14{slash} install is going to run this
25:15workflow, where the agent is actually
25:17going to copy everything into the code
25:19base. So, this is a fully reusable
25:21system. It's designed to be deployed
25:23across your code bases. You know, a lot
25:25of stuff I bring to the channel and
25:26share on the channel, I need myself. I
25:28need a reusable, extensible,
25:30customizable AI developer workflow
25:31system that allows me to build software
25:33factories. So, I built it. I have and
25:35will invest a lot of time into this
25:37specific tooling because it has the
25:39properties that I mentioned, observable,
25:41customizable, reusable. Out of the box,
25:43it gives you what you need, and then you
25:44can see all the cookbook recipes here.
25:46How I like to design my skills is
25:47there's a central idea, super simple
25:49software factory, deploy and operate
25:51repeatable agents plus code in any code
25:53base. So, that's the kind of core idea.
25:55And then the cookbook is the kind of
25:56lazy loaded actions, the incrementally
25:59adoptable contexts that the agent can
26:02look at to execute, right? So, we have
26:03this table here, we can go ahead and go
26:04into render view, and you can see the
26:05requests routing. So, the requests set
26:07up the factory in a new repo, create an
26:09ADW, modify an ADW, create the config,
26:12set up a new agent roster, so on and so
26:14forth, right? I've taught an agent how
26:15to operate the super simple software
26:17factory. And this is agentic access, one
26:19of the five key pillars of agentic
26:21engineering. You are moving too slowly
26:23if you are doing pretty much anything by
26:25hand unless you're building the system
26:27that builds a system. That's exactly
26:29what I've done here. That meta concept
26:30is going to reign true throughout the
26:32age of agents. If you're doing something
26:34you can teach your agents to do, why
26:36aren't you? This system here is a great
26:37example of that, super customizable. Of
26:39course, it's got a bunch of templates in
26:41here. It uses all this to create that
26:43first version inside your code base, and
26:45then of course, after that, the whole
26:46goal is that you should customize it to
26:48make it your own. The tests I have set
26:50up here are not the tests you need. The
26:51plan quality is not the plan quality you
26:54need, so on and so forth. It's designed
26:55to be a customizable. It's atomic.
26:57Software factories give you more
26:58leverage on your prompt. How well is
27:01based on the effort, time, and
27:03investment you put into your AI
27:05developer workflows, which make up your
27:07software factory. There's a ton of
27:08engineering work you just don't need to
27:10be doing anymore. That continues to be
27:12true. So, why are you? This is something
27:14I think about. This is something I tell
27:16myself and other engineers when I'm
27:18sitting here working, prompting back and
27:19forth like an idiot. So, it's time to
27:21shift. It's time to make that next jump.
27:22Build your software factory. Deploy it
27:24into the cloud. Set up sandboxes so that
27:27you can push all the 80% junk work of
27:30engineering away off to your agent stack
27:32in a reliable, repeatable way so that
27:34you can focus on the real net new hard
27:36work your agents can't do without you.
27:38So, feel free to use the super simple
27:39software factory. Pull in ideas. Steal
27:41it. Roll it into your own software
27:42factory. It's here for you. Again, every
27:44single week my goal here on the channel
27:46is to bring you ideas you've seen,
27:48permutations of ideas, some net new
27:50ideas, and some just raw, hitting
27:52examples of how you can use agents and
27:54code, how you can engineer to scale to
27:57get your work done, right? To build
27:59valuable software. At the end of the
28:00day, that's what it's all about. Those
28:02who can orchestrate intelligence at the
28:04highest level to accomplish work are
28:06winning. They're just in the lead right
28:08now, and the software factory is the
28:11next permutation. It's the next step of
28:13this. It's not just about agents. It's
28:14about agents plus code. We're getting to
28:17a key point in the age of AI where if
28:19you're not running a software factory,
28:20you're going to be behind. We're just at
28:22another branding point here, and I want
28:24to make sure I say it clearly and
28:25concisely to you so you're aware.
28:27Building these out, it takes time. I
28:29wanted to give you a head start here
28:30with the super simple software factory.
28:32Always remember this. Vibe coding is not
28:34knowing how your system works and not
28:35looking. Agentic engineering is knowing
28:37how your system works so well you don't
28:40have to look. You want to rise with the
28:42ceiling of agentic engineering, not the
28:44floor of vibe coding. If you want a
28:45complete understanding of how to build
28:48AI developer workflows, which make up
28:50your software factory, check out
28:51Tactical Agentic Coding. Link in the
28:54description for you. You're going to
28:55scale far beyond AI coding and Vibe
28:57coding with advanced agentic
28:58engineering. So powerful, your code base
29:00runs itself. This is what the name of
29:02the game is right now in engineering.
29:04This is for the top 20% of engineers. If
29:07you're a noob, again, if you're Vibe
29:08coding, I'm sorry, this just isn't for
29:10you. But if you're doing real
29:11engineering work, check this out. This
29:12is going to be ultra valuable. All the
29:14ideas embedded in here are going to be
29:16the ideas to help you advance your
29:17career. Thousands of engineers have
29:19taken this. I built this by hand from
29:21scratch. If you don't want to pay to
29:23play, that's totally fine. Check out the
29:24links in the description. The Super
29:26Simple Software Factory is going to be
29:27completely free and available to you.
29:29Also, if you want to understand why I
29:30didn't mention loop engineering once in
29:32this video, watch the first video linked
29:34in the description. What you're really
29:35looking for is the software developer
29:37life cycle, not loop engineering. We go
29:39deep into that topic and really the idea
29:42of building software factories in that
29:43video, so check that out if you're
29:45interested. You know where to find me
29:46every single Monday. Stay focused and
29:48keep building.

About this transcript

This page contains the full transcript of My Super Simple Software Factory (For Agentic Engineers) by IndyDevDan, generated from the public captions YouTube serves with the video. The transcript has 6,606 words across 966 segments, with the original timestamps preserved so you can click any line to jump to that moment in the embedded player.

What you can do with it

Use the transcript to take notes, quote the speaker, build a study guide, generate a summary with ChatGPT or Claude via the YouTube Summary tool, or export it as a timed subtitle file with YouTube to SRT. You can also re-open it in the transcriber to choose a caption track available on the video.

Free YouTube transcript tool

YouTube2Text is a free YouTube transcript generator — no signup, no daily limit. Paste any YouTube link and get the full transcript instantly, with timestamps, click-to-jump, caption language selection, AI prompts for ChatGPT, Claude, and Gemini, and exports to TXT, SRT, VTT, or Markdown.