"ZERO to RUNNING Software Factory In 16 Minutes (LIQUID Software)" — IndyDevDan
Why this is in the vault
Lesson two of IndyDevDan's Tiny Software Factories series, following the lesson-one note already filed. It shows a concrete init/configure/specialize workflow for mounting an agent-driven app shell into an existing codebase, plus a set of agent-UX features (tool summaries, budgeted subagents, agent access parity) that map directly onto how RDCO runs and observes its own agents.
Episode summary
Dan takes an empty "tiny software factory" template and, with one skill and one command, installs it into a mock prompt-to-image app (Hues), then feeds a 150-line plan to a configure skill to turn it into a product-analytics agent. While that runs he walks through the 14 features added in tier two, framed as "liquid software" that reshapes itself to the problem. The through-line is the move from in the loop to near the loop.
Key arguments / segments
- [00:00:24] Thesis: stop chasing primitives (agents, models, tools); the meta-optimization is moving from in the loop to near the loop to out of the loop. Being in the loop makes you the bottleneck.

- [00:01:00] Factory architecture has two goals: rapid three-stage deployment, and software that takes the shape of the problem. "Liquid" software is customizable from day one, by you and by the agent inside it.

- [00:03:19] Tier-two template: an empty factory (focus center, actions right, list left) with generic agent tooling that has no purpose until specialized. Great defaults plus full customization is the pitch.

- [00:05:15] Step 1, initialize: a single /tsf skill with an init command copies the factory files into the target app. The template itself stays untouched.

- [00:06:53] Step 2, configure: a long plan prompt (about 150 lines) is passed to the configure skill, which mounts the factory against the codebase and specializes it (here, product analytics). "Agents building agents."

- [00:08:00] Feature: tool summaries. A lightweight model condenses batches of tool calls into readable sentences; cadence and visible rows are settable, and changed by prompting the agent itself.

- [00:10:01] Feature: specialized subagents with their own model tier, system prompt, tools, and hard time and spend caps (example: 25 cents per launch, 10 minutes, up to 4 agents). Every run is traced and listed in settings.

- [00:12:01] Agent access parity: every click or setting a human can change, the agent can too. Demo: one prompt retunes subagent defaults, enables cron pulse, builds a theme, rearranges the nav, and opens settings.

- [00:15:00] Close: one super agent for everything is not how to solve specialized problems on repeat; specialization is the advantage. Lesson three adds small agent teams.

Notable claims
- [00:00:24] The engineers pulling ahead are optimizing how they work (loop position), not picking primitives. Assertion, no data offered.
- [00:08:00] Tool-call output grows hard to read as models get more capable; the choice is "look away and pray" or "engineer and measure." Summaries are his answer.
- [00:12:01] Agent access parity (UI actions all agent-callable) is presented as the key enabler of moving at agent speed.
- [00:15:00] Specialized agents on repeat problems beat a single general agent. Plausible but unbenchmarked here.
- Note: the 16-minute "zero to running" framing covers mostly file copy plus a pre-written plan; the planning effort is off-screen.
Guests
None. Solo demo by IndyDevDan.
Sponsorship
House promo: the description and framing push the agenticengineer.com "Infinite Agentic Engineering" course, of which this series is the preview. No third-party paid sponsor is named in the transcript. Bias: the factory template is the product being sold, so "great defaults" and the 14-feature value claims are marketing-adjacent; the demos run on his own mock app rather than a real production workload.
Mapping against Ray Data Co
Strength: medium. Three portable ideas. (1) Tool summaries by a cheap model are a pattern for RDCO's own observability of cron and subagent runs, where raw tool output is currently unreadable at a glance. (2) Budgeted subagents (model tier plus time and dollar caps per launch) resemble RDCO's delegation model/effort pairing and could be made explicit as per-run caps. (3) Agent access parity matches the advisor-mode, agent-does-reversible-work stance: every HQ control should be agent-callable. The "near the loop" framing is the same argument as the founder's decision-vs-action split. The product itself (a sellable template) is not an RDCO dependency; RDCO is a personal-license, phData-first setup, so this is idea mining, not adoption.
Related
- [[2026-11-02-indy-dev-dan-tiny-software-factories]]
- [[2026-10-26-indy-dev-dan-elite-agentic-engineers-leaving-the-loop]]
- [[2026-10-12-indy-dev-dan-pi-durable-proactive-agents]]