next level nerdingTiny software factories
Tiny software factories
IndyDevDan's smallest useful factory: one problem, one always-on agent, a list of things, and prompts on a schedule, with you near the loop to approve and give notes. He builds it with six shortcuts he says won't scale, on purpose, because they get you to something working today.
Jump to the feature map, his system prompt, or build the smallest version. The why behind it is on In loop, near loop, out loop.
The video
19 minutes, posted Nov 2, 2026, on IndyDevDan's channel. It's lesson 1 of his paid course, shown free as a preview. The video has no chapters; these are ours. Every timestamp on this page opens the video at that moment.
- 0:00 Lesson one: an empty factory and a running one
- 0:45 Done wrong, on purpose: the six shortcuts
- 1:04 Tiny factories vs his bigger course (near vs out the loop)
- 2:17 What a tiny software factory is
- 3:00 In the loop vs near the loop
- 3:48 One skill, one command
- 4:57 Initialize, configure, specialize
- 5:35 The feature map
- 6:27 F1 to F4: empty factory, agent, list, focus
- 9:21 F5: agent access parity
- 10:03 F6: the core four
- 11:51 The agent changes its own settings
- 12:59 F7: an extensible harness
- 14:01 F8: change the look by chatting
- 16:17 F10: cron prompts
- 18:01 Close the browser, it keeps working
15 signals
The whole video in 15 boxes. Each links to the part of this page that explains it.
- 012:17
One problem, around the clock
His definition: a factory built for one specific problem, where an agent that starts on its own works around the clock in a place that doesn't switch off, and you sit near the loop, not in it.
More - 023:00
In the loop you prompt. Near the loop you respond.
Instead of typing every turn, you give feedback, make decisions and approve work the agent has already done. Each note you give makes the factory better.
More - 033:26
You are the slow part
His claim: 80% or more of the agent work we do today could run without us, with the right system in place. Not checked; it's his estimate.
More - 040:45
Done wrong, on purpose
Six shortcuts that won't scale: one agent, cron inside the server, a JSON config, pages the agent writes, SQLite on one box, and bash in your codebase. Each gets you to something useful fast. Each breaks somewhere.
More - 053:48
A template you stamp, not a platform you build
A big factory is always one more feature away. A tiny one is a working template: one skill and one command mount it next to your code, and you bend it to the problem.
More - 067:47
Every product is a list of something
The screen has three parts: the agent on the right, a list on the left, and the thing you're looking at in the middle. His question to you: what's in your list?
More - 079:21
Anything you can click, the agent can do
He calls it agent access parity. Every button and setting in the app has a matching tool the agent can call, so you can ask for anything in plain words.
More - 0810:03
Own the core four
Context, model, prompt and tools. The app shows all four and lets you change them. His line: you don't really own your agent if you can't.
More - 0910:49
Pick the right model for the job
Models show as grades, from SOTA S+ down to Lightweight D, not by name. Don't fix on one model; pick the right trade between quality, cost and speed.
More - 1011:51
The agent can change itself
One sentence and it switched off its own coding tools and turned its thinking up to max. He calls it reflection for agents: powerful, and dangerous if you don't set limits.
More - 1112:59
The harness is a stack of slices
The agent is several add-ons stacked up: factory basics, coding tools, pages, images and factory controls. Each one brings its own tools and its own part of the prompt. Switch them on and off.
More - 1215:54
Software meant to be changed
Themes, menus, hotkeys and animations all change by chat. He calls it liquid software: the tools you use every day should bend to how you work.
More - 1316:17
A cron prompt is a name, a schedule and a prompt
That's all. It's the fastest way to get repeat work running while you're away, and it costs nothing to set up.
More - 1417:08
The agent pushed back
Asked to add a page every minute, it named two problems: its file tools were off, and three pages a minute is about 4,300 a day. He told it to go ahead anyway. A good agent checks your maths.
More - 1518:01
Close the browser. It keeps going.
The agent lives in the app's server, not your tab. Refresh or close the window and the scheduled job still fires and new pages still appear.
More
Words on this page
42 terms, in plain words. Skip this if you already run agents on a schedule.
- Agent
- An AI model that can use tools (read files, run commands, edit pages) in a loop until a job is done, not just answer once.
- Agentic engineering
- Dan's name for building systems around AI agents, as opposed to typing prompts one by one.
- Software factory
- A setup where agents do repeat software work (writing, checking, updating) with little or no human typing.
- Tiny software factory (TSF)
- Dan's small version: one problem, one always-on agent, one screen, built from a template in minutes.
- Empty factory
- The template before you give it a job. Everything is built (agent, list, pages, schedule, settings); it just has no purpose yet.
- In the loop
- You type every turn. The work stops when you stop.
- Near the loop
- The agent starts and does the work on its own. You come in to give notes, decide or approve.
- Out the loop
- The agent starts and finishes on its own; you only read results. Dan's paid course covers this; this page doesn't.
- Proactive agent
- An agent that starts work without being asked, because something (a time, an event) wakes it. On his slide: durable agent + trigger + sandbox.
- Durable agent
- An agent that keeps its memory and keeps running through crashes, restarts and closed laptops.
- Trigger
- Whatever wakes the agent up: a time of day, a new email, an error in a log, a button press.
- Sandbox
- A separate, walled-off computer or container the agent works in, so its mistakes can't reach the rest of your machine.
- Cron
- The old Unix way to run something on a schedule. `*/5 * * * *` means every five minutes.
- Cron prompt
- A prompt the agent runs on a schedule. In the factory it's three fields: a name, a schedule and the prompt.
- Harness
- Everything wrapped around the model: its tools, its prompt, its settings, the app it lives in. Same model, different harness, different results.
- Extension
- One add-on slice of the harness. In the factory each one brings a set of tools plus a section of the prompt, and can be switched off.
- Tool / tool call
- A named action the agent can take, like pages_create or tsf_settings. A tool call is the agent using one.
- Agent access parity
- Every control a person can use in the app has a matching agent tool, so the agent can do anything you can.
- Core four
- Dan's four parts of any agent: context (what it remembers), model (which AI), prompt (its instructions) and tools (what it can do).
- Context window
- How much text the model can hold in mind at once, counted in tokens. The factory's is 1 million.
- Token
- A chunk of text, roughly three quarters of a word. Models charge per million tokens in and out.
- Compaction
- Summarising the older part of a long conversation so the agent can keep going without running out of room.
- Model tier
- A grade for a model (SOTA, workhorse, lightweight) instead of its brand name, so you can swap the model behind a grade later.
- SOTA
- State of the art: the best and most expensive models available right now.
- Thinking level
- How long the model reasons before it answers. Off, low, high or max in this app. More thinking costs more and takes longer.
- System prompt
- The standing instructions the agent reads before every request: who it is, what it's for, how it should work.
- Alias
- A short word that expands into a longer instruction. In his factory, starting a message with `co` means "chat only, use no tools".
- Generative UI
- Screens the agent builds for you on request (here, HTML pages), instead of screens a developer built in advance.
- Meta skill
- A skill whose job is to set up other things. His `/tsf install` stamps a whole factory into a folder.
- Skill
- A folder of instructions (and sometimes scripts) an agent loads when the task needs it, usually started with a slash command.
- Data flywheel
- Each piece of feedback makes the system a bit better, which makes the next round of feedback more useful.
- Observability / traces
- Records of what the agent did: each run, its thinking, every tool call, what it cost. How you check work you didn't watch.
- SQLite
- A small database that lives in one file on one machine. Easy to start with, harder to share or scale.
- JSON config
- Settings kept in one plain text file (here `.tsf/settings.json`). Easy to edit, by you or the agent.
- Bash
- The command line. An agent with bash can run any command your user can, including deleting things.
- OpenRouter
- One account and one API key that reaches models from many companies. The factory's model grades point at models there.
- Pi
- An open-source coding-agent harness you can change. The factory's coding tools are labelled "pi's default tools".
- Anti-pattern / dark pattern
- A way of building that works now but causes trouble later. Dan uses both words for his six shortcuts.
- Blitzscaling
- Growing as fast as possible and accepting the mess. Dan's word for this course's approach.
- Local maximum
- The best result you can get without starting over a different way. Good enough here, not the best possible.
- Liquid software
- Dan's phrase for software built to be changed constantly, often by the agent itself.
- IA3
- Infinite Agentic Engineering, Dan's paid course on fully autonomous (out-the-loop) systems. TSF is a squeezed version of it.
What it is, and what it does
A small app with one job. An agent lives inside it, works on a schedule while you're away, and leaves the results in a list for you to check. You start from a ready-made empty one and give it a job. 2:17
His definition, from the slide
“A Tiny Software Factory is a software factory built to solve one specific problem, where a proactive agent works around the clock in a durable environment, with you near the loop instead of in it.”
- key property 1One problemBuilt for one job. A general assistant is not a factory.
- key property 2Around the clockIt doesn't wait for you to show up. A schedule or event starts it.
- key property 3Durable sandboxIt lives somewhere that stays on and walled off, not in your chat tab.
- key property 4Near the loopYou come in to approve and give notes, not to type every step.
Before and after · his slide3:00
In the loopYou prompt
- You type
- Agent answers
- You type again
Every turn starts with you. Close the laptop and the work stops.
Near the loopYou respond
- Cron wakes the agent
- Agent does the work
- Result waits
- You approve or give a note
The work is already done when you check in. Your notes feed the next run.
His pitch for why: “you and I are the bottleneck”, and 80% or more of today's agent work could run without us. Every note you give a near-loop agent makes the next run better. 3:24
Six factories you could run · basic to advanced
basic · His suggestion, on the empty factory's start screen
What changed this week
- The list
- One page per week of git changes
- The cron prompt
- Every Friday at 4 pm, write this week's changes as a page in plain words
- You
- Read it, star what matters, forward it to the team
basic · His demo used Python, TypeScript and Rust, every minute
A study shelf
- The list
- Folders per subject, one page per concept
- The cron prompt
- Every morning, add one new concept page to each folder, with an example and a common mistake
- You
- Read one page with coffee; tell it what was too easy
basic · FakeNerd's example
Reading list digest
- The list
- One page per article you saved
- The cron prompt
- Every evening, summarise new saves in five lines and tag them
- You
- Skim the list, archive the rest
advanced · His cron job, shown on screen (switched off)
Codebase pulse
- The list
- One live page called Pulse
- The cron prompt
- Every 5 minutes, add the code changes that matter since the newest entry, newest first
- You
- Glance at it between meetings
advanced · FakeNerd's example
Support inbox triage
- The list
- One page per customer thread
- The cron prompt
- Every 15 minutes, sort new emails, draft replies, flag anything about money
- You
- Approve or edit each draft before it sends
advanced · FakeNerd's example
Dependency watch
- The list
- One page per package you depend on
- The cron prompt
- Every night, check for new versions and security notes, open a branch for safe updates
- You
- Merge the branch or say why not
Everything named
What he names or what's on screen. The factory itself is his and isn't public; everything under it you can get.
The agent and its models
Open-source agent harness
Pi
The factory's coding tools are labelled "pi's default tools: read, write, edit and bash". Pi is the base the other slices stack on. In: you can change every part. Out: it's a toolkit, not a finished app.
Model gateway
OpenRouter
The factory's model grades and its image tools go through OpenRouter, so one key reaches many companies' models. In: swap models without code changes. Out: one more service between you and the model.
Read from the screen
Six model grades
SOTA S+ and S, Workhorse A and B, Lightweight C and D. The demo runs on Workhorse A. The names behind the grades are hidden by default (a "Full model names" switch shows them).
Read from the screen
Image model
The Images slice says it makes and edits images through OpenRouter with "GPT Image 2.5 Sunburst by default". Not used in the demo.
Where it runs and keeps things
Where you see it
A browser
The factory is a local web app (127.0.0.1 in the demo). The browser is only a window: close it and the agent keeps working on the server.
One of his six shortcuts
Cron in the server
Schedules run inside the factory's own server process. In: nothing else to set up. Out: if the server stops, so do the jobs.
One of his six shortcuts
JSON config
Settings live in `.tsf/settings.json`, including which real model each grade points to (`models.stack`). The agent can edit it through its settings tool.
One of his six shortcuts
SQLite
One database file on one box. The Observability feature searches costs, traces, thinking and tool calls with it.
Said, not shown
A sandbox
"Point it at your repo, drop it in a sandbox." The demo runs on his own machine; he doesn't name a sandbox product here.
His own names
His course, lesson 1
TSF, Tiny Software Factories
The template app and the course that teaches it. No public repo; it's part of his paid Phase 3 course. You can build the same shape yourself (see Try it).
His meta skill
/tsf install
One skill and one command that mounts a new factory next to your codebase. Shown as a slide; the install itself isn't shown.
His bigger course
IA3
Infinite Agentic Engineering: fully autonomous, out-the-loop systems. He says TSF is a squeezed, lossy version of it.
Left out
The course pitch and pre-sale link, and levels 2 to 4 of his factory, which this lesson doesn't show. The /tsf install skill is only a slide here, so there's no skill section.
The feature map
He reveals the factory one feature at a time on a map: how much value each gives against how much effort it takes. Click a feature to read it, or press Start to follow his demo and watch which features it uses. 5:35
His feature map · value up, effort acrossfactory level 01 / 04 · 11 / 15 features
value 5· best
value 4
value 3
value 2
value 1
Top-left is the sweet spot: most value for least work. Cells are his. F9 and F11 appear only on the map at the end; the four locked cells are for later lessons.
Follow one factory, install to morning
Ten beats from his demo: stamp an empty factory, fill its list, let the agent change itself, schedule a job, close the browser. Watch which features light up at each step.
F10 · value 5, effort 3
Watch at 16:17Cron prompts
Prompts on a schedule, run by the same agent while you are away.
A list of jobs, each a name, a schedule and a prompt. Press R to open them.
What he showed
A switched-off job "Codebase pulse" (every 5 minutes), then a new one made by chat: "Language Concept Minute", one new concept page per language every minute.
Your own version · FakeNerd
One line in your computer's crontab, or the schedule feature in your agent app. Start daily, not every minute.
Watch out
Every minute is 1,440 runs a day. Count before you schedule.
Positions and the card lines in quotes are read from his screen. The plain lines, “your own version” and “watch out” are FakeNerd's.
His system prompt
The standing instructions his factory agent reads before every request. 414 tokens, transcribed from his screen. The whole prompt is 3.8k tokens: this part, plus a short alias snippet and one section per add-on. 11:16
- 01
Who it is
One always-on agent, one problem, one engineer. And the three ways work arrives: chat, cron, a button on a page.
- 02
Mission
A default (watch the codebase, answer, do what's asked) plus an instruction to replace it. This is the "specialize" step.
- 03
Workspace
Where it works, where the factory's own code lives, a rule not to touch it, and the time zone for schedules.
- 04
How you work
Use tools, never claim work you didn't do. Pages over long replies. Short cron replies. Offer to schedule repeats. Ask before anything destructive.
His SYSTEM_PROMPT.md · read from the screen
You are the agent inside "Tiny Software Factory", a Tiny Software Factory: one durable, always-on agent that works on one problem for an engineer around the clock. Work reaches you three ways: the engineer writes in the chat, a cron job sends you its prompt on a schedule, or someone presses a button in a page you built. ## Mission Help the engineer who owns this codebase. Keep an eye on it, answer questions about it, and do the work they hand you. Replace this section with the one problem this factory solves, who it serves, and what a good day of work looks like. ## Workspace - You work in /Users/indydevdan/Documents/projects/agentic-engineer/tiny-software-factories/tsf-1. Relative paths in your tools start there. - The codebase root is /Users/indydevdan/Documents/projects/agentic-engineer/tiny-software-factories/tsf-1. The factory itself lives in /Users/indydevdan/Documents/projects/agentic-engineer/tiny-software-factories/tsf-1/.tsf. Do not change the factory's own code unless the engineer asks. - Times and cron schedules are in America/Chicago. ## How you work - Do the work with your tools. Never claim you did something you did not do with a tool. - Put information worth keeping in sight into pages (pages_create), not into long chat replies. Keep chat replies to a few sentences and lead with the result. - On a cron run, do exactly what the job's prompt asks, keep the pages it owns current, and reply in one or two sentences. - When the engineer asks for something recurring, offer to schedule it with tsf_cron. - Ask before anything destructive or hard to undo: deleting files, rewriting history, spending real money.
FakeNerd fill-in · use as AGENTS.md or CLAUDE.md
You are the agent inside [FACTORY NAME]: one always-on agent that works on one problem for [WHO] around the clock. Work reaches you three ways: [WHO] writes in the chat, a scheduled job sends you its prompt, or [OTHER TRIGGER, e.g. a new file lands in inbox/]. ## Mission [THE ONE PROBLEM, in one sentence.] It serves [WHO]. A good day of work looks like: [WHAT IS DONE AND WAITING BY 9 A.M.]. ## Workspace - You work in [FOLDER]. Relative paths start there. - The list lives in [FOLDER]/pages: one file per [ONE ITEM, e.g. customer thread]. - Do not change this file or the schedule unless [WHO] asks. - Times are in [TIME ZONE]. ## How you work - Do the work with your tools. Never claim you did something you did not do. - Put anything worth keeping into a page, not a long chat reply. Lead with the result. - On a scheduled run, do exactly what the job asks, keep its pages current, and log one line to runs.log: time, job, what changed, rough cost. - When [WHO] asks for something recurring, offer to schedule it. - Ask before anything destructive or hard to undo: deleting, sending, paying, deploying.
Note the second line of his Mission: “Replace this section with the one problem this factory solves.” That's the template waiting for a job. Our fill-in adds a run log line, so you can check scheduled work you didn't watch. His alias snippet is one row: start a message with co and it means “Chat only. Do not call any tools.”
What he typed
Five messages from the demo, exactly as typed on screen, with what the agent did and a fill-in version. Then two FakeNerd starters for building your own.
018:05
He typed
explain the basics of python, typescript, and rust, in nested folders in our pages.
Fill-in
Explain [TOPIC] for [WHO], in nested folders in our pages: one folder per [PART], one page per [ITEM], plus a Start Here page that compares them.
What it did: Made a Language Basics folder with Python, TypeScript and Rust inside, a basics page in each, and a Start Here page comparing all three.
029:35
He typed
list pages tools
Fill-in
list your tools for [AREA], with one line each on when you'd use it.
What it did: Listed its five page tools and how each works, plus how buttons on a page can message it back.
0311:51
He typed
disable all coding tools, update thinking level to max.
Fill-in
disable [TOOL GROUP], set thinking to [LEVEL]. Read the settings back and tell me what you can no longer do.
What it did: Switched off the coding slice (read, write, edit, bash), set thinking to max, read the settings back to check, and said it can no longer touch files.
0414:26
He typed
update to another dark theme, then add context bar to the agent nav bar, then add status in the global nav bar on the left side
Fill-in
switch to [THEME], then put [ITEM] in [BAR], then put [ITEM] on the [SIDE] of [BAR].
What it did: Picked a deep-ocean theme, put the context bar in the agent's top bar and the agent's status on the left of the main bar.
0516:54
He typed
Add cron: every minute add a new file to each of our programming languages where you'll breakdown one new concept each.
Fill-in
Add cron: every [INTERVAL], [ONE SMALL JOB] for each [ITEM]. Before you create it, tell me how many runs a day that is and anything blocking it.
What it did: Pushed back with two blockers and a cheaper suggestion. After "confirm anyway use page tools" it created the job Language Concept Minute.
FakeNerd starter · build the three-panel factory
Build me a tiny software factory: a small local web app for one problem. The problem: [ONE SENTENCE]. One item in the list is: [ONE ITEM, e.g. a page per day of repo changes]. Layout, three panels: - Left: the list of items, in folders. Read from ./pages. - Center: the open item, shown as a page. - Right: a chat with you, the same agent that runs the scheduled jobs. Rules: - Every button in the app must have a matching command you can run, so I can ask for anything by chat. - One settings screen showing: model, the rules file, which tools are on, and the scheduled jobs. - Scheduled jobs are a name, a schedule and a prompt. Keep them in one file. - Log every scheduled run to runs.log: time, job, what changed, cost if known. - Keep it small: one server, one file of settings, no login. It runs only on this machine. Start with the smallest version that shows one item. Tell me what you skipped.
FakeNerd starter · specialize it for one problem
Read AGENTS.md (or CLAUDE.md) and the pages folder. Specialize this factory for: [THE ONE PROBLEM]. 1. Rewrite the Mission section for that problem, who it serves, and what a good day looks like. 2. Suggest 3 scheduled jobs (name, schedule, prompt). For each, say how many runs a day and what it could break. 3. List the tools this job does not need, so I can switch them off. Don't create the jobs yet. Show me first.
The core four
“You do not truly own your agent if you do not have core four control.” His settings screen gives each of the four its own page and a one-key shortcut. 10:03
ContextC
1M window. A summary starts in the background at 200k while the agent keeps working; at 502k the next request waits for it. Compact now, or start a new context.
For you: Know when your agent starts forgetting, and start fresh sessions on purpose.
ModelM
Six grades with prices, thinking off / low / high / max, and how much of the thinking to show in chat.
For you: Use a cheap grade for scheduled chores and a top grade only for hard calls.
PromptP
3.8k tokens in five sections: his system prompt (414 tokens), an alias snippet, and one section per extension (Pages alone is 2.7k).
For you: Read your whole prompt once. Most people have never seen theirs.
ToolsT
Every tool grouped by the slice it comes from, each with its own switch: coding, pages, images, factory control.
For you: Switch off what this job doesn't need. Fewer tools, fewer surprises.
Six model grades · price per million tokens out, read from the screen10:49
- SOTA S+$4 in · $20 out · 1M
- SOTA S$2 in · $10 out · 1M
- Workhorse Aused in the demo$0.15 in · $0.60 out · 1M
- Workhorse B$0.14 in · $0.28 out · 1M
- Lightweight C$0.15 in · $1 out · 262k
- Lightweight D$0.02 in · $0.09 out · 131k
Same scale for every bar. The workhorse he runs is about 33 times cheaper per output token than the top grade, and still has a 1M-token memory. That's the trade he means by “the right model for the job”. Real model names are hidden behind the grades; a settings file maps each grade to a model on OpenRouter.
The agent changes its own settings · he calls it reflection11:51
- 1He typesdisable all coding tools, update thinking level to max.
- 2It reads its settingstsf_settings read
- 3It changes themtsf_settings update: disable_extensions, thinking
- 4It checks its own worktsf_settings read, then: “Both done and verified… I can't touch files or run commands now, so say the word when you want them back.”
His warning, in his words: “this capability can be very dangerous if you don't control it properly.” It can change itself “up to some useful limit that again you can set.” The captions have him say thinking is now high; the screen and the agent's reply say max.
The harness, as a stack
“This agent is a composition of several agent harnesses.” Each slice brings tools plus its own part of the prompt. Switch a slice off and both go. 13:10
One agent · five slices · from his Harness settings page
Factory factoryalways on
The agent's identity, mission and workspace, from SYSTEM_PROMPT.md, plus enabled snippets. Always on.
Coding tools coding-toolsoff
Pi's default tools in the agent's workspace. Switched off in the demo, by the agent.
readwriteeditbash
Pages pageson
Keeps the list of folders and pages on the left current.
pages_readpages_createpages_updatepages_delete
Images imageson
Makes and edits images through OpenRouter.
image_createimage_edit
Factory control tsfon
The agent can do anything you can do in this interface.
tsf_crontsf_settingstsf_snippetstsf_themestsf_contexttsf_uitsf_traces
Two things to take from it. First, the Factory control slice is what makes parity work: seven tools that let the agent do anything you can do in the app, including schedules and settings. Second, prompt size adds up: the Pages slice's instructions alone are 2.7k tokens. More slices, more to read on every request.
Cron prompts
“If you want to move near the loop and eventually out the loop, you're going to need cron.” A cron prompt is a prompt on a schedule, run by the same agent while you're away. 16:17
- field 1NameWhat you'll see in the list and the logs.Codebase pulse
- field 2ScheduleStandard cron timing, in the factory's time zone.*/5 * * * * (every 5 minutes)
- field 3PromptWhat the agent is told each time. His uses four headings.Purpose · Variables · Instructions · Workflow
His job “Codebase pulse”, every 5 minutes · read from the screen
## Purpose Keep a page called Pulse current with the codebase changes that matter, newest first, so the engineer sees what moved since they last looked. ## Variables - PAGE: Pulse - SINCE: the time of the newest entry on PAGE ## Instructions - When PAGE does not exist yet, create it and take SINCE as one day ago. ## Workflow [not readable on screen]
FakeNerd fill-in · a cron prompt for your list
## Purpose Keep a page called [PAGE NAME] current with [WHAT TO WATCH], newest first, so [WHO] sees what changed since they last looked. ## Variables - PAGE: [PAGE NAME] - SINCE: the time of the newest entry on PAGE ## Instructions - When PAGE does not exist yet, create it and take SINCE as one day ago. - If nothing changed, add nothing and reply "no change". - Never [THING IT MUST NOT DO, e.g. send email, delete files]. ## Workflow 1. Read PAGE and find SINCE. 2. Collect [ITEMS] newer than SINCE. 3. Write one line per item at the top of PAGE, in plain words. 4. Reply in one sentence: how many items, and the most important one.
The agent pushed back · its reply, read from the screen17:08
No file writes right now
You had me disable the coding tools, so I can't create real files. I can write each concept as a page instead.
Every minute is 3 new pages a minute
So roughly 4,300 a day, and that list gets very hard to clean up.
Its suggestion
One run a minute that adds a concept for one language in turn, or keep all three and go hourly.
He replied “confirm anyway use page tools” and it made the job. For a demo that's fine. For your factory, the agent's suggestion is the one to take. Then he closed the browser: the job kept firing and new pages kept appearing. 18:01
How often is too often · runs per day
- Every minute1,440
- Every 5 minutes288
- Every 15 minutes96
- Hourly24
- Daily1
FakeNerd's chart. Multiply by what one run costs and what it writes. His demo job adds three pages a run, so every minute means about 4,300 pages a day, the agent's own sum.
The six shortcuts
He calls them dark patterns and anti-patterns: ways of building that get you from zero to useful fast and won't scale. “It's not meditation. It's Xanax.” Know which ones you took, so you know what to fix when it hurts. 0:45
- One agentOne always-on agent does the chat, the schedule and the edits.Why it's fastNothing to coordinate.Where it breaksA long job blocks your chat; one bad instruction affects everything it does.When it hurts, move toSeveral agents with one job each, and a hand-off between them.
- Cron in serverThe schedule runs inside the factory's own server.Why it's fastNo scheduler to install.Where it breaksServer down means no jobs and no record of the ones it missed.When it hurts, move toA separate scheduler or queue that retries and logs misses.
- JSON configAll settings in one file, `.tsf/settings.json`.Why it's fastEasy to read and edit, by you or the agent.Where it breaksNo history of who changed what, and the agent can edit its own limits.When it hurts, move toSettings in git, checked on load, with limits the agent can't change.
- Agent pagesThe agent writes the HTML pages you read.Why it's fastAny screen you want, by asking.Where it breaksPages drift in layout, and a page can run scripts you never read.When it hurts, move toFixed page types the agent fills with data.
- SQLite boxOne database file on one machine.Why it's fastZero setup, fast, easy to search.Where it breaksOne machine, one writer at a time, and a backup only if you make one.When it hurts, move toA hosted database once a second person or machine needs it.
- Bash accessThe agent can run shell commands in your codebase.Why it's fastIt can do anything you can at the command line.Where it breaksIt can also delete, leak or overwrite anything you can.When it hurts, move toA sandbox, an allow-list of commands, and a guard on dangerous ones.
The six names are from his slide and description. He says each one breaks somewhere but doesn't say where in this lesson, so the last two columns are FakeNerd's. For bash access on Claude Code, his guard hook is disler/claude-code-damage-control.
Try it, smallest version first
- 01
Name the one problem and the list
One sentence for the problem, one word for an item. "Keep me current on what changed in our repo" and "one page per day". If you can't name one item, pick a smaller problem.
- 02
Make the empty factory
A folder with three things: a rules file (the system prompt, filled in), an empty pages folder for the list, and a runs.log. Use the fill-in prompt below as AGENTS.md or CLAUDE.md. Works on your laptop, in Cloudroom, or in bb (getbb.app).
The system prompt, fill-inMake the empty factory
mkdir -p my-factory/pages && cd my-factory touch runs.log # paste the fill-in system prompt into AGENTS.md (Codex, Cursor) or CLAUDE.md (Claude Code)
- 03
Run it once in the loop
Open your agent in the folder and give it the job by hand. Read the pages it writes. Fix the rules file until one run comes out right without follow-ups.
Run it once in the loop
# Claude Code claude "Do today's run: [THE JOB]. Write the result as a page in pages/." # Codex codex "Do today's run: [THE JOB]. Write the result as a page in pages/."
- 04
Run it with no chat window
Most coding agents can run one prompt and quit. If this works with no help, the job is ready to leave your hands.
Run it with no chat window
# Claude Code claude -p "Do today's run: [THE JOB]. Write the result as a page in pages/. Log one line to runs.log." # Codex codex exec "Do today's run: [THE JOB]. Write the result as a page in pages/. Log one line to runs.log."
- 05
Add one cron prompt
Start daily, not every minute. On a Mac or Linux machine, open crontab -e and add one line. Many agent apps can also schedule a prompt for you. If the log says command not found, swap claude for the full path `which claude` prints.
Add one cron prompt
0 7 * * * cd ~/my-factory && claude -p "Do today's run: [THE JOB]. Write the result as a page in pages/. Log one line to runs.log." >> ~/my-factory/cron.log 2>&1
- 06
Review in the morning, give one note
Read the new page and runs.log. Add one line to the rules file about what to do better. That's you near the loop, and that note is the flywheel.
- 07
Give it a screen, if you want one
Only now: ask the agent to build the three-panel app (list left, page center, chat right). Use the starter below. This is the bit his template gives you ready-made.
Three-panel starter - 08
Move it somewhere that stays on
Your laptop sleeps. A spare Mac mini or a cloud sandbox doesn't. Before you do, switch off any tool the job doesn't need.
How to use Pi Durable
Next to the others
The other factory pages on this site, and how this one differs.
- In loop, near loop, out loop Dan's ladder, a week earlier: three agents he runs and how to move one task one rung.The why. This page is the build.
- How to use Pi Durable The library under his agents, step by step: agents that survive restarts.The durable part, done properly
- Ondrej's mini software factory Loops that check their own work and run around the clock.Also small, more about checks
- Ras Mic's factory Seven skills and one AGENTS.md: isolate, build, prove, ship.Bigger: a whole build line in skills
- Steve Sewell's factory A factory that fixes bugs on a timer.One problem, like TSF, but out the loop
- Warp: software factories Crawl, walk, run: from you doing the work to agents doing it.The industry version of the idea
- The bot as manager Rob Shocks on one chat that manages many coding agents.Near the loop, through chat
- LLM benchmarks How to pick a model on cost, speed and quality.The model grades, in depth
FakeNerd's take
The honest part is the title
Most factory videos sell the finished machine. This one names its six shortcuts up front and says each will break. That makes it easier to trust, and easier to know when you've outgrown it.
Steal the shape, not the app
There's no repo, but the shape is the lesson: one problem, a list, an agent that can do whatever you can click, and a cron prompt. You can build that with a folder, a rules file and one crontab line this afternoon.
The best moment is the pushback
The agent did the sum (about 4,300 pages a day) and suggested something cheaper. Write that into your own rules: before any schedule, say how many runs a day it means.
Parity cuts both ways
An agent that can switch off its own tools can switch them back on, and raise its own limits. Near the loop is safe only if the dangerous switches need you. He says so too; it's easy to miss in the demo's speed.
Attribution
- “Tiny Software Factories: Agentic Engineering DONE WRONG” by IndyDevDan (posted Nov 2, 2026). The definition, the four properties, in loop vs near loop, the six shortcuts, the feature map, the factory app, its system prompt and the demo prompts are his. Slide text, map cells, settings, prices, the system prompt and the agent's replies are read from the screen; where the captions disagreed, the screen won.
- The video is lesson 1 of his paid Phase 3 course, shown free as a preview; the end card advertises a launch on Nov 30. The course pitch is left out. You don't need the course to use anything on this page. In earlier videos he says he takes no sponsorships.
- Not checked: the 80% figure, and which real models sit behind the six grades (hidden on screen). There is no public repo for the factory as of Nov 2, 2026.
- The chapters, the plain-words lines, “your own version” and “watch out” on the map, the last walkthrough beat, the six examples (except the two marked as his), the “where it breaks” columns, the runs-per-day chart, every fill-in and starter prompt, the try-it steps, the sibling list and the takes are FakeNerd's. Not sponsored by anyone on this page.