Summaries > Technology > Software > Tiny Software Factories: Agentic Engineering DONE WRONG...

Tiny Software Factories: Agentic Engineering Done Wrong

https://www.youtube.com/watch?v=1v7ldJiyH-Y

TLDR Tiny Software Factories are customizable, always-on apps where proactive agents use pages, tools, and scheduled prompts to tackle focused problems while users review results and improve the system. They’re quick to set up and reshape, offering a practical shortcut to value while keeping users near the loop.

Key Insights

Start with One Small, Specific Problem

A tiny software factory is most useful when it focuses on a clear task that can be handled continuously by an agent. Begin with a ready-made factory template, then define the problem and the pages or documents the agent needs to work on. Keeping the initial scope small helps you move from setup to useful results quickly. Treat early shortcuts as a way to test value, not necessarily as the right design for a mature system.

Give the Agent the Same Capabilities as the Interface

Agent access parity means that actions available in the user interface also have corresponding agent tools. This lets the agent create, edit, and organize pages instead of relying on the user to perform every step. When configuring a factory, check that the tools needed for the task are available to the agent. Matching UI and agent capabilities helps the system work at agent speed while keeping its operation understandable.

Configure the Agent’s Core Settings

Set the agent’s context, model and thinking level, system prompts, and tools to suit the work. Provide relevant instructions and access to the resources it needs, while limiting tools that are unnecessary or risky. You can also set boundaries for changes the agent may make to its own configuration. Review these settings as the task evolves so the agent remains capable without being given more access than it needs.

Use Pages and Artifacts to Organize Work

Structure the factory around the information the agent is expected to produce or maintain. For example, use nested pages for different programming languages, projects, or topics, and store results as readable Markdown documents or other artifacts. A clear structure makes it easier for both the user and agent to find and review work. Customize navigation and other interface features when they improve the workflow.

Schedule Repeat Work with Cron Prompts

Use a cron prompt when a task should run on a recurring schedule without requiring you to stay in the application. Each scheduled job needs a name, a schedule, and a clear prompt describing the expected work. Start with a simple, low-risk task, such as adding one new concept to a set of learning folders, and review the results before expanding the schedule. A durable factory can keep the job running even when you refresh or close the browser.

Stay Near the Loop and Improve the Factory

Let the agent complete routine work, then review its results and provide feedback rather than prompting for every individual step. Use that feedback to refine prompts, tools, context, and page structure. This creates a practical data flywheel: each review helps the factory perform better on future work. Keep scheduled tasks and agent autonomy within boundaries that match the importance and risk of the task.

Questions & Answers

What is a Tiny Software Factory (TSF)?

A small, rapidly deployable software system that uses proactive agents to solve a specific problem continuously, keeping the user near the loop so they can review completed work and provide feedback.

Why is a Tiny Software Factory useful?

It can be set up beside a codebase in minutes, customized through prompts and tools, and run continuously in a sandbox. It frees the user to review work and improve the system through a data flywheel.

What are the four levels of factory capabilities evaluated by?

The course introduces four levels of capabilities, evaluated mainly by the effort required and the value provided. The first level is the empty factory: a ready-made template without a specific purpose.

What is agent access parity?

It is the principle that every action available in the user interface has a corresponding agent tool, allowing agents to operate and configure the factory at agentic speed.

What parts of the agent can users control?

Users can control the agent’s core four: context, model and thinking level, system prompts, and tools. They can also configure context compaction and tool details, and set limits within which agents may adjust their own settings.

What are cron prompts, and how do they work?

Cron prompts schedule an agent to run a repeated job using a name, schedule, and prompt. In the factory, the R hotkey creates a cron; for example, one can run every minute to add concepts to Python, TypeScript, and Rust folders.

Do scheduled cron prompts keep running when the user leaves?

Yes. Because the application is durable, a cron can continue running after the user refreshes, closes the browser, or leaves.

Summary of Timestamps

Lesson One introduces Tiny Software Factories (TSF): small, quickly deployable software systems built around proactive agents that work continuously on one specific problem. Rather than requiring users to prompt the agent at every step, the goal is to keep the user near the loop, reviewing completed work and guiding improvements.

The lesson presents agentic-engineering anti-patterns as practical shortcuts for moving from zero to value and shipping useful work quickly. These approaches are framed as short-term techniques, not ideal long-term practices; the course contrasts them with the more autonomous, out-of-loop engineering covered by IIA3.

A tiny software factory can sit beside an existing codebase, be customized through prompts and tools, and run continuously in a sandbox. By letting the agent complete work for later review, it frees the user to provide feedback and strengthen the system through a data flywheel.

The course evaluates factory capabilities across four levels, with effort and value as the main measures. Level one is the empty factory: a ready-made template with a persistent agent in the right sidebar and a replaceable set of pages on the left. The demonstration adds nested Python, TypeScript, and Rust pages for the user and agent to work in.

The factory is a customizable generative-UI application where agents work with pages, artifacts, and Markdown documents. Its central principle is agent access parity: every action a user can take in the interface has a corresponding agent tool, allowing the agent to operate and configure the factory quickly.

Users can control the agent’s “core four”: context, model and thinking level, system prompts, and tools. This includes settings such as context compaction and detailed tool configuration. Within limits set by the user, agents can also adjust their own settings—for example, changing their thinking level or disabling coding tools.

The agent uses an extensible harness made up of capability layers, including factory, coding, page, image-generation, and factory-control harnesses. Users—and agents—can also reshape the experience by changing themes, navigation, context bars, animations, and hotkeys. This flexibility supports the idea of “liquid software” that adapts as needs change.

Cron prompts introduce scheduled work that can move the user closer to—or eventually outside—the loop. Each cron consists of a name, schedule, and prompt. In the factory, the R hotkey opens cron creation, making it quick and free to set up a recurring task.

The example cron runs every minute, adding a fundamental concept to folders for Python, TypeScript, and Rust. It produces explanations such as Python context managers, TypeScript utility types, and Rust lifetimes, including why each concept matters and common mistakes to avoid.

Because the factory is a durable application, scheduled work continues even if the user refreshes the page, closes the browser, or leaves. The agent can keep building up useful work in the background, while the user returns later to review the results and provide feedback.