Welcome to Tiny Software Factories, lesson two. Here we take your “tiny factories” to the next level by understanding their role as “liquid” software. More on that in a moment. First, let's talk about the big picture . If you want to multiply your impact as an engineer, you need to stop obsessing over primitives: agents, models, tools, bindings. What should you focus on then to get maximum results? The goal is to optimize how you work. The most important meta-optimization that engineers are currently implementing is the transition from “ person in the loop” to “person near the loop” and , finally, to completely exiting the loop. Why is this optimization important? Because the scale of intelligence working on your behalf directly impacts your performance as an agent engineer . When you are stuck “in the loop,” you are constantly exchanging requests with your agent, and he works until he needs you. Here, make no mistake, you are the "bottleneck." And now that you are “near the loop,” your proactive agents work for you
[00:01:00] around the clock and only stop when they reach a decision point that requires your attention. When you are “out of the loop,” your system works for you 24/7 without any expectation that you will intervene at all . Here at Tiny Software Factories, we focus on moving from “in the loop ” to “near the loop.” But Tiny Software Factories is not just about that. The architecture of the Tiny Factory is designed with two key goals in mind . The first is rapid deployment in three stages: initialization, configuration, specialization; The second is taking shape for the problem you are solving. So what does it mean to take the shape of the problem you are solving? As intelligence increases and token values decrease, a new type of software emerges that changes form depending on the problem it is meant to solve. And that's the real value here . It is constantly changing shape. The more you learn about your problem, the more your software changes shape to solve it. This new “liquid” software has a unique feature— it is designed from day one to be
[00:02:00] customizable. A tiny software factory—this is what “liquid” software is all about. It is designed to adapt to the specific problem you need to solve 24/7, being “near the cycle” rather than “in it.” If you are interested in this new class of “liquid” software, stay with us, and let us initialize, configure, and specialize your powerful “tiny factories.” In the second lesson and throughout all Tiny Factories, we will use a function map to gradually reveal the capabilities within the factory. This is the second level of four factories. We'll go through the 14 features one by one and explain why they're valuable to your engineering. Each function belongs to one of the three dimensions. We have effort, value, and also a third dimension—skills. As in the first lesson, we will simplify everything and focus on effort and value. If you missed the first lesson, be sure to watch it. There we look at the basics of the architecture of a tiny software factory
[00:03:00] . Here we add 14 new features on top of it to expand the capabilities of your factories right out of the box. The first and most important feature of every tiny factory is that it is empty. Your second-level factory template contains generic agent tools that have no purpose until you define one. This is a key feature of software factories . Make no mistake, having a template that you can customize with great default settings is a huge advantage. You'll see it again here in the second lesson. Here is our empty factory. We have focus in the center , actions on the right, list on the left. Every app is a list of something. What's on your list? And inside the second-tier software factory, we have a bunch of new features to consider. You can see some of them here, in the settings menu. Before we look at our new features, we need to prepare the three-step process that every empty factory goes through to become operational. Initialization, configuration, specialization. We specialize this
[00:04:00] tiny factory to work as a data analyst for Hughes' image generation application from the first lesson. This is a simple application for converting text to images. It will serve as a demonstration application for us to explore the tiny factory. In this three-step process, the first step is to initialize the factory. In the first step, we use one skill, one command with one factory template, one empty factory, and we move our empty factory inside our target application. So , we have an empty factory. We will port it to any existing or new codebase you have. And then we will perform the second step, which is to configure . But the first step here is simply initializing the factory. We will do this using a powerful agent in a loop with our single TSF skill. Let's demonstrate this right now. In VS Code you can see that we have a TSF two codebase. It's a tiny, second- tier factory, and it only has the bare essentials. We have a skill catalog here with a super skill of a tiny factory that just does a bunch of tasks. Next we
[00:05:00] have the tiny software factory application in .tsf and a few configuration files along with a README. So we want to install a new tiny software factory inside our analytics application , where you see our Hughes application. This process is simple. We don't do any of this manually anymore. We use agents to work at "agent" speed. I'll open a terminal and run in-loop. I intentionally named this command so that it would always be understood when I sit down to work, sit down in a chair, and have a dialogue, /tsf to activate our skill . And we're going to run init. And then we will pass the path where we want to install our software factory. This will be one directory higher inside the TSF before analytics. OK? So I'll start this. And now the state-of-the-art in-loop agent will get to work. This is mostly just a quick copy of the relevant files for the tiny software factory. You see here that these files have been copied . We have a skills catalog here, and we have the codebase of a tiny software factory in the .tsf directory. And TSF two remains completely untouched. Remember, TSF
[00:06:01] two is an empty template. This is an empty codebase. It's an empty factory that does nothing until you give it a specific purpose. Fantasy. You see that our in-loop agent reports success. It was successfully installed. Just a few files. They chose several new ports for us. Fantasy. This leads us to the next step in the process of initializing our factory. If you want to go from an empty factory to a working one, this is the process. The next step is, of course, factory settings. This is factory planning. This is where you and your agents sit down, write a detailed, lengthy prompt, which is essentially a plan, and then pass it to the TSF configuration skill. This is how you mount your codebase and start customizing it to work with the specific problem you are trying to solve. We are turning our tiny software factory into a data analytics software factory. And in a moment we'll demonstrate why this is so powerful. But in the same in-loop agent, we will do a CD, that is, change directories. We will move on to the TSF 2 analytics codebase. Let's launch. And now we
[00:07:01] will launch TSF, that is, the skills there. And then we'll do the setup workflow. We jump into the empty factory template. I'll just address this prompt that my agent and I have been working on . This is exactly how you want to specialize your tiny software factory . This is just a plan. 150 lines. And you can see here a single line of code that turns this initialized software factory into a product analytics agent . So, here's what he does. I'll just get the absolute link to it and we'll run it. Now we are going to configure the system. We will run this query in the system. Large collection. The agent gets to work. This will take some time . This is the process of taking your empty software factory, placing it next to your new or existing codebase , and now we let your agent work on actually mounting the codebase. So let's let our agent do the work. This will take some time. While our internal agent builds the system that builds the system, we'll look at the new features of our empty factory, which can be quickly redeployed as a liquid software to solve any problem you encounter on an ongoing basis, as we've added a
[00:08:00] bunch of new features to the empty factory for its redeployment. Let's work through these powerful features now, as they really expand on the capabilities gained from the first lesson. So, what new features are there in the empty code base of the second lesson? The first brand new feature is the tool summary. This is when a lightweight model summarizes the exact tool calls your agents make as they work, so you can quickly observe and understand what's happening. As intelligence grows, the models powering your software factories will become increasingly complex to understand, as each tool call will be filled with a wealth of information . You have two options. You can turn away and pray, or you can design and measure. Tool summaries reveal what your alien language model is actually doing and summarize the work done into sentences you can understand at a glance. Let's take a close look at this so we can see what it really looks like. So, I'll say "ping" to make sure our agent is online. Fantastically. And I will do CWD. And remember, this is our agent working in our empty software factory. And you can see here that for the PWD team, we
[00:09:01] can always look inward. Now it's wrapped up in this nice summary. Let's set this up, because remember, this is a rare software. It is designed for change. It is designed to change shape at any time. LS, let's do a few more runs here. That's all. So, we got a good resume. And then we'll do it. I will say to set the tool summary every three tool calls and set the visible rows to two. As you know, we use the concept of agent access parity, which we will mention later. You can see here that our agent has changed its own settings. Let's run another query. Wonderful . Summarize the architecture of this application. With each team, first it comes in, and now they are summed up and grouped together. You see there are two challenges there, one, two. And we can quickly understand what our agent did, very, very quickly. So, read the read me, understand the directory structure. And, of course, there is a clear summary of what our agent did. This is a very, very powerful feature as your agent scales and becomes more complex and it becomes harder to keep track of everything it does, and you'll see how powerful this is throughout this lesson.
[00:10:01] This is a classic example, improved delegation to subagents. These are disposable agents for a single task. The main difference from the subagents you are used to is that we can specialize aggressively. So, what does this mean? We can give our agent its own model level, its own system prompt, its own tools, and its own budgets. Specifically, we have time budgets and expense budgets. So these are granular subagents with great restrictions and great default settings . And all of this is available. If we open our settings here, we have tool summaries that include a special summary prompt that you can change. And of course, we have the lines, we have the level, we have the mindset that our agent has set, and we have the summation of every third tool call. All of this can again be customized and adapted. But moving on to our subagents here, so the model, the mindset, the budget, it will be capped at 25 cents per launch, and it will run for up to 10 minutes with up to four agents. So, fully customizable, all traces and agent information will be listed here. Let's run some subagents. Run three subagents to generalize the TSF server, client, and skill respectively.
[00:11:01] Use a lightweight model, limit execution time to 1 minute with a budget of 15 cents. Create a page with their results. So, we'll start this. And, as you might expect, we'll see some asynchronous subagent launches. Here is the server, here is the client, and here is the generalization. We can always come back to this. Server, client, skill, they're back. That's all . Completed results. And now our agent creates a page by performing a bunch of agent actions. If you look at the focus in the center and our page on the left, you'll see how this was created. This is a great concise breakdown of the TSF architecture. We don't need to go through all of this, but you can see that our agent went through it very quickly and got the job done in a fraction of the time thanks to powerful subagents . The answer didn't have to be perfect, so we scaled our models down into subagents to just get the job done quickly. Again, if we open the settings again and go to subagents, we will see these exact launches. If you don't measure, you can't improve. So we measure everything, right down to our subagents. And this again emphasizes the key idea: with Tiny Software Factory, with a system that you can use to work around the loop,
[00:12:01] not in it, we see everything. And, of course, we can customize everything, because it's "liquid" software. You see the responses, that is, all the tool calls. And if we scroll up , we see the exact task that the agent was performing: query input, input synthesis, and then output results. We own our own agent tools, so we can configure them to see everything, and that's exactly what we've done here. Keep in mind , this is just a second-level Tiny Software Factory template . These capabilities consistently point to a very important feature of Tiny Software Factory. And this is, of course, agent access parity . This remains relevant at the second level. We emphasized this at the first level. Every mouse click, every setting change—your agent can also execute equivalent commands. And why is this so important? This allows you to move at the speed of agents. You and I are slow. Let's just admit it. Let's use the best tool for engineering work—agents. You and I are not the best tool. This is one of the many
[00:13:00] reasons why it is so important to move from working “in the loop” to working “near the loop.” You are shifting more work to your agents, and you are not doing it out of laziness. You are agent engineering the results you expect. We will demonstrate this key feature throughout the process. We're already doing this, but let's show you what it looks like. So, we'll say something like this . Set the default subagent settings to "light", 30 cents each. Set the tool summary to "every call". Enable cron pulse. Create a new "orange on black" theme, but make it pleasing to the eyes. Set a theme for agent status, model selection, tool calls, input, output, and total tokens in the global navigation panel in compact mode on the left, open settings, tools, and then list hotkeys by logical groups. So, I'm just setting up a bunch of different things. The main goal is to show that our agent has access parity. It can do everything we could do inside the system. So you see again how fast the agent updates the entire system. It opens the settings for me. He can control this interface. He can operate an empty factory without my involvement. And that means he can do the same for a
[00:14:01] working factory. Again, this is a topic of " liquid" software that configures itself using an internal agent. It opens the tools page here. You see them all . We can switch between description mode and parameter mode if we want. And you can see all of our tools grouped by the framework we developed for the system. We'll show some of these additional features in a moment, but here you can also see all the hotkeys that we can work with. This is how I refresh and navigate the interface very, very quickly. I use these hotkeys. I improve the developer experience for every software factory I now work for . I move at the speed of an agent and dynamically adapt the software to the task we are solving. In this case, we are not solving any problem. I'm just demonstrating the capabilities of the tiny software factory architecture. And this is the power of “liquid” software. It is designed to be customizable down to the keystrokes. So , there's a lot of information here. Of course, you can see that we can customize the model . We have tool calls, I/O tokens, and so on, just as you would expect. This is where the magic of the tiny
[00:15:00] software factory really comes into play . She completed the configuration of the empty software factory to a working state. Despite popular belief, having one super agent doing everything for you is not the best way to consistently solve specialized tasks 24/7. In the age of agents, anyone can create anything with a single request. Specialization is your advantage, and moving closer to the work cycle multiplies it , because now you don't have to sit still to get the work done. You build systems that build systems on your behalf. You move closer to the cycle so you don't get stuck in it. In the third lesson, we will go further, specializing intelligence in the factory using small teams of agents. In addition, we will add another set of features on top of the first and second level software factory functionality. At this stage, as a tiny software factory participant , you have enough tools to solve specific tasks around the clock , staying close to the cycle, not
[00:16:00] inside it. After each completed lesson, ask yourself: what tasks can I consistently solve using tiny software factory? See you in lesson three, where we scale up and create small teams of agents that interact with each other to work faster and more efficiently than they could alone. And all this becomes possible thanks to investments in your empty and operating tiny software factories — your “liquid” software. See you there.