# Tiny Software Factories: Agentic Engineering DONE WRONG

## Executive summary

This lesson introduces the concept of Tiny Software Factories (TSF), a methodology for rapidly building small, useful software systems using agentic engineering anti-patterns. TSF aims to move engineers from being 'in the loop' (manual prompting) to 'near the loop' (reviewing and approving agent work). The factory is designed to solve one specific problem, operating with a proactive, durable agent that works around the clock. Key features include Agent Access Parity, the ability to configure the 'Core Four' (Context, Model, Prompt, Tools), and scheduled automation via 'Cron prompts,' enabling rapid deployment and continuous improvement.

## Key takeaways

- Definition of a Tiny Software Factory: A TSF is a software factory built to solve one specific problem where a proactive agent works around the clock in a durable environment, keeping the human 'near the loop' rather than 'in the loop.'
- The Goal: Near-Loop vs. In-Loop: The primary advantage is that the human is not required in the loop; instead, they move near the loop to provide feedback, make decisions, and approve work, creating a data flywheel for factory improvement.
- Agentic Anti-Patterns (Blitzscaling): TSF is a 'highly compressed lossy version' of full agentic engineering, focusing on quick wins and rapid deployment (blitzscaling) rather than building fully autonomous, out-of-loop systems.
- Scheduled Automation with Cron Prompts: Cron prompts are scheduled prompts run by the agent while the user is away, providing a powerful, simple way to add repeat jobs and maintain continuous operation.

## Technical details

- TSF Architecture Components: The factory is built around three core features: 1) A durable agent (on the right), 2) Pages (on the left, representing data/codebases), and 3) Focus (in the center, the primary working area).
- Agentic Access Parity: This critical feature ensures that every control available in the UI is accessible to the agent via a matching tool, allowing the agent to self-modify and operate at 'agentic speed.'
- The Core Four: Full control over the agent requires mastering the 'Core Four': Context, Model, Prompt, and Tools. Customizing these elements is key to building unique agents.
- Agent Self-Modification: With proper configuration, the agent can modify itself, such as disabling coding tools or updating the thinking level (e.g., setting it to 'high').
- Extensibility and Customization: The architecture is designed to be customized via 'harnesses' (e.g., factory harness, page harness, image generation harness) and user experience elements (themes, hot keys, animations).

## Practical implications

- Engineers can rapidly prototype and deploy functional agentic systems by focusing on solving one specific problem at a time, bypassing the time sink of building comprehensive, all-encompassing tools.
- The concept shifts the engineering bottleneck from manual prompting (in-loop) to structured feedback and review (near-loop), significantly increasing productivity.
- The ability to schedule agent actions via Cron prompts allows for continuous, unattended background work, making the system durable even when the user is offline.

## Topics

Agentic Engineering, Software Factories, LLM Agents, Workflow Automation, DevTools, Build Scaling, agenticengineer.com

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