Welcome to Tiny Software Factories, lesson one. "Tiny Software Factories" is a mini-course where we create small, useful software factories that work for you 24/7, so you can move from being inside the loop to working alongside it. In each lesson you will see an empty factory and a working factory. This allows you to first understand the possibilities and then apply them to a real problem. In the first lesson, you will dive into the world of Tiny Software Factories and learn how not to do agent engineering. I know, that sounds a little strange. Why would you study agent engineering incorrectly? Let me explain. Tiny Software Factories is a crash course in gradually scaling your agent engineering to the nearest useful threshold. In TSF, you will learn about many "dark patterns" of agent engineering that will not scale. Instead, you will move quickly, break, fix, and release products. But these are anti-patterns. So I want to
[00:01:00] make that clear. "Tiny Software Factories" is a highly condensed version of the core course in agent engineering. Here we focus on agent engineering "alongside the loop". IA3 focuses on much more efficient but more complex "out-of-the-loop" agent engineering, where we build fully autonomous systems that operate without your involvement. What you will see here is not recommended as a long-term solution. These anti-patterns are designed to help you get results by sacrificing almost everything except getting the job done. This is blitz-scaling for agent engineering. This is a quick solution. This is not meditation, this is "Xanax". It's not training, it's GLP-1. This is a useful local maximum for achieving results at any cost. Now that we've got that out of the way: just because it's not technically correct doesn't mean your tiny software factories can't be extremely useful. At TSF, we stop worrying about making everything perfect and focus on making everything work. If you are interested in these ideas and
[00:02:00] want to perform tasks at the speed of agents, let's build tiny software factories. So, let's start with the obvious question. What is a tiny software factory? A tiny software factory is a factory built to solve a single specific problem, where a proactive agent works 24/7 in a stable environment, and you are next to the loop, not inside it. There are key elements of this definition that are worth highlighting. Built to solve a single task with a proactive agent working 24/7 in a persistent environment where you are alongside the cycle, not in it. You will see these properties as recurring themes as you master tiny software factories. Now that we have agreed on the definition, let's ask the next important question. Why is this valuable? How is a tiny software factory more valuable than working at a terminal with constant requests to an agent? In the loop versus near the loop. The big
[00:03:01] advantage of your tiny factory is that you are not needed directly in the loop. Instead, you go into "near-loop" mode to provide feedback, make decisions, and approve work that the agent has already completed. The feedback you provide to the agent "near the loop" creates a data flywheel that makes the factory improve with every signal you give. Let's face it: you and I are the "bottleneck," and 80% or more of the work we do now could be done without us with the right system in place. The tiny software factory quickly leads us to this. In a loop, you create queries. Near the cycle you react. The secret is to have the right system in place, not to sit chained to a bot in your office chair. What else makes a tiny software factory so valuable? As you will see, the tiny software factory is expanding rapidly. It is designed for change. With one meta-skill and one command, bam, you can deploy a new factory next to your codebase to solve a specific problem. Point to the repository, run in the sandbox—and
[00:04:01] you'll go from scratch to a working agent system in minutes. Building a scalable software factory takes a lot of time, even with powerful language models. The result always needs another function, and later you realize that it doesn't cover all the scenarios you're trying to build it for. A tiny software factory offers a huge advantage because it is a compact operating system with great default settings that can be quickly deployed again and again. It's a quick fix, and that's the whole point. What else makes the architecture of the tiny factory you'll see so valuable? It is expandable in its structure. It is designed to adapt. Every query, tool, hotkey, extension, or topic is available to you and your agent in a loop. This means you can quickly build a system that builds a system, accelerating the transition from "in the loop" to "near the loop." You can change it so that it adapts to solve any problem you have. Initialization, configuration, specialization. Last but not
[00:05:01] least: the architecture of the tiny factory is special in that the agents "near the loop" inside it do not stop working for you. They contain a persistent agent and a trigger in a "sandbox", giving you a proactive assistant. You can set it to start working before you wake up, and when you check the status, the work will already be waiting for your inspection. She doesn't wait for you to start working, she works for you and then waits. We have an agent system that can be instantly deployed to resolve a specific issue 24/7 with a proactive agent. But what does a tiny software factory actually look like? As we work with tiny factories, we will gradually reveal their capabilities using a function map. We will go through four levels of the factory, each containing unique features that we will explore step by step. Every feature has three dimensions: the effort
[00:06:02] to unlock, the value you get from putting in the effort to build and use that feature. Additionally, each function has certain skill requirements that you must meet. To keep it simple, in the spirit of a tiny factory, we will focus on value and effort. The first and most important characteristic of tiny factories is that they are empty factories. An empty factory is a template. She is completely ready. It has all the features for specialization, but no specialization yet. An empty factory has no purpose until you give it one. Let's take a look at a real empty factory right now. In the browser, you see an empty factory in front of you. It's a minimalist interface with two sidebars, which we'll take a look at now. Each feature we consider is an opportunity that you can adapt to solve your problems.
[00:07:06] Let's see what's inside the empty factory, with our next function—the agent on the right. This is a permanent agent in your factory who is always active and available at any time. If we open the right sidebar and send a message, you will see the classic agent ready to go. This is something you are very familiar with. Any application can be enhanced with an agent to move at agent speed. Any software factory has to work with something. What is this empty factory working on? This brings us to the third function. On the left we have lists. Any product is a list of something. What's on your list? Here, on the left, we have pages. These are the pages that you and your agent work with. As you will see, this is designed to be a replacement. But with just these three features, we can start
[00:08:01] our tiny factory. Explain the basics of Python, TypeScript, and Rust in the subfolders on our pages. We're launching this. You see Python, TypeScript, and Rust in folders in a tiny software factory. She creates these pages. It fills a tiny software factory. There are pages here that we can open, each one of them, and see what's there. We start here, and you see that our central overview is now focused on content. This brings us to the next function. Focus in the center. The core of what you and your agent are working on is located at the center of your tiny software factory. Focus your attention here. So, for our empty software factory, we have a simple application based on a generative interface, where there are pages, artifacts, and simple Markdown documents that our agent can use, build, modify, and configure on our behalf. You see here the basics of Python, TypeScript, and Rust languages generated by our agent, all available for us to
[00:09:01] analyze, review, and customize. But these two challenges that our agent just completed point to a very important property of tiny software factories. The next key feature of the tiny software factory is agent access parity. Anything you can do, your agent can do. Each control in the interface has a corresponding agent tool. This has serious implications, allowing you to move much faster than your competitors, as it allows you to act at the speed of agents. Let's focus on our agent here. Display a list of tools for pages. And our agent lists all the tools he has for working with his pages. Our agent really has access to everything inside the tiny software factory. Let's look at another key feature and I'll show you exactly what I mean. You don't truly own your agent unless you have control over the "
[00:10:00] foundation four": context, model, prompt, and tools. A true software factory should give you full control over your agents. In our user interface, we have exactly this. If we go to the settings, you will see an exhaustive list of options. We have the basic, "base of four," as well as additional settings. Let's talk about the "base of four," because that's what makes up the foundation of your agent. If you master these four elements, you master your agent. And if you can customize that, you can create agents that no one else can create. And in your tiny software factory, that means everything. As you can see, we have a context bar, auto-compression at 200k, and forced compression at 500k. Once our agent crosses the 200k threshold, it will start compression in the background. We'll talk about long-lived agents a little later, but this is their key feature. You see that we have a choice of models and levels of thinking, distributed by level. This is very important. You don't want to be limited to one model, you want to use the right model for a specific task with the optimal balance of performance, cost, and speed. We have a system prompt that we specially designed. It performs
[00:11:01] very specific tasks inside the software factory. And, of course, we have our tools. You can see all the tools our agent has. And we also have settings. So now we have a few key features piling up here. And we can demonstrate it. If we go to the "core four" settings, you will see a focus on context there. We have auto-compression enabled. We can see the details of our model. We see all of our prompts: custom, advanced, which we'll get to later, and additional ones that we can add to our agent at any time. And, of course, we can view all the tools our agents have access to here in quick view mode. We can show a description of each one, and then display the full parameters in whatever syntax we use to load the tools. But our opportunities are starting to accumulate. So let me show you what it really means when your agent has agential access equality. I'll close the main view, focus on our agent, and then run "disable all coding tools" and upgrade the thinking level to maximum. I will start this process and our agent will be able to modify itself. This is one of the key benefits of having a reliable agent with the right tools. This is
[00:12:01] a reflection for agents. If you open the settings now, you will see that our thinking level is set to "high". And if we go to the tools, you'll see that all the coding tools—read, write, edit, bash—are now disabled. Our agent has a certain set of tools that we can customize, and it can change on its own up to a certain limit that you can set. Of course, this capability can be very dangerous if not managed properly, but agential equality allows your agent to do everything you can, and the most important tweaks any agent engineer can make right now are the configuration of your agents and the code around them. And if you can do it at the speed of an agent, you'll move much faster. We can configure the "basic four" using agential equality of access. This leads us to another great feature of Tiny Software Factory that you can take advantage of. You can create an extensible management system. This miniature software factory, the near
[00:13:00] loop agent, is built on individual functional blocks. What do I mean? If we go back to the settings menu and go to advanced options, instead of "harness", you will see that this agent is a composition of several tool environments. We have a factory environment. We have coding tools, which as you can see, we have completely disabled. Next we have the page environment. We have an image generation environment, which is another level of capability, as well as factory controls. Except for the default encoding agent settings, we added four more layers on top of that. And all of this is fully customizable, as you will see in the following lessons. We will show you how to engineer new capabilities inside your near loop mini software factory. Tools that are fun to work with provide a better experience. And a better experience means you're more willing to invest in the tools you build and use. That's why the next feature of our mini software factory is so important: customizable DX and UX. You can
[00:14:01] set up your mini software factory down to the very basics. We're talking about themes, navigation bar updates, hotkeys, and animations. Customize the factory to suit your work style. As you probably noticed, I opened the settings using a different hotkey. If you want to move fast, the tools you use should facilitate that. And "Tiny Software Factory" was created for this very purpose. What do I mean? Let's continue to develop this topic. So, I'll run this. I would say: upgrade to a different dark theme, then add a context bar to the agent navigation bar, and also add status to the global navigation bar on the left. Let our agent get to work and it will check the topics. He has full access to the agent's features and has updated our settings. So, something has changed. We see the status of our agent in the navigation bar. You saw that we updated our theme. So, we again have full agent access to everything that can be done in the interface. This means we can move at the speed of agents. And I mean full access parity, even for such simple things. Deselect page. Anything you can do, your agent can do. It is the small operations that you and I
[00:15:01] perform every day that, over time, add up to a big result. This context bar is a bit compressed here. Move the context bar to full width mode. This will give us more space. This will push her down. That's it. You can take advantage of this. You can customize this. You can really do whatever you want with it. You can do it yourself. We won't be using much context, so we'll just remove the context bar. I don't really like this theme, so we'll go back to the theme settings and I'll just update it. We will switch to the "north" option. We can continue to customize everything however we want. Of course, in the navigation bar you can see exactly how our agent organizes the user interface. Fully customizable, fully extensible. We can update the animation to understand when our agent is working and when it is not. And we also have hotkeys. Fully configure and customize the application to operate very quickly. In a world where software changes at the speed of light, our core tools and applications need to be built with this in mind. This is rare software. It is created for change. It is created for customization. This is a key feature of Tiny Software Factory. Switching
[00:16:01] back to the standard TSF theme. What else makes Tiny Software Factory so powerful? If you want to move to working in a loop, and later outside of it, you will need cron, specifically cron prompts. This is exactly what you thought. These are schedule prompts. They are performed by your agent while you are away. Let's take a look at this, because it's a huge step forward for your agent design. Because with Tiny Software Factory, this idea quickly deploys for any of your problems. So, the default hotkey for cron is R. You see that every cron has a simple set of elements, right? It has a name, a schedule, and a clue. That's all. This allows you to instantly launch recurring schedules and tasks at no cost. Let's create a cron and start getting real benefit from our agent in a loop. I'll say: add cron, create a new file every minute for each of our programming languages. Because remember, we asked him to write the basics of languages here. And then I'll
[00:17:01] say: figure out one new concept for each. We will launch it. Let's see what our agent thinks about this. Two blockers, no file write permissions. That's okay, he shouldn't need it. Every 3 minutes—that's a lot in a day. This is normal. Still confirm. Use page tools. TSF cron. It's gone. Here it is. It runs this workflow every minute. It will read these pages and add a new foundation to our folders for each of our languages. Of course, this is just a random example to show what it really looks like, what it feels like inside your tiny software factory. But here you see context managers for Python, classic with operators, the context manager decorator looks great. TypeScript utility types look great. We have an explanation of why this is important and common mistakes below. Steeply. And then Rust lifetimes, borrowing tags, compiler hints about validity time, why it matters, common mistakes. Fantasy. So we're getting to the point where the minute is almost up, and now our agent will get this event again. Here she is. Cron is running, and it doesn't matter if we're here. This is an important part. I can
[00:18:00] close this. This is a stable application. I can refresh the page as much as I want. I can close this browser window if I want, and our agent will just keep working, adding new features. Cron prompts are an extremely important, powerful, fast, and easy way to add recurring tasks to your software factory. You move fast, you get things done, and now, with this next feature, you turn your empty software factory into
[transcript ends here — auto-sub cut off near video's end, ~18:36 total runtime per yt-dlp metadata]