Raw transcript — "My Super Simple Software Factory (For Agentic Engineers)" — IndyDevDan

What's up engineers? Any Dev Dan here. If you're building systems of agents that operate for you, stick around. This is going to be a valuable one for you. If you're mindlessly vibe coding slop, this video is not for you. Click away. Thanks. See you next time. Software factories are massively misunderstood and under appreciated. The key is to understand that they're useful for one reason alone. They give you more leverage on your prompt. That's it. Now, the amount of leverage you can get is determined by the quality of your investment into your software factory. At the lowest levels, you chain together a few agents to do a little more work for you with some minor configuration. At the highest levels, you build a system of agents plus code that operates without you just as well and sometimes even better than you would. In this video, I'll share my super simple software factory to show you how you can begin to unlock this leverage. This factory is a combination of the big ideas we've discussed on the channel and inside TAC, except it's been rebuilt from the ground up for the next phase of agentic engineering.

[00:01:01] If you understand that agents plus code beats agents alone, and if you want another edge in the age of agents, stick around and let's break down the super simple software factory. There are three key design principles I've embedded in the super simple software factory. It's observable, it's customizable, and it's reusable. All things that are essential to operating in the age of agents. Observability is key. If you can't measure your agents, you can't improve them. We can click into any AI developer workflow here and see exactly what happened in a swim lane view. We have Kimmy K3, Gemini 3.6 Flash, GPT 5.6 Terra, GPT 5.6 Luna. We have an abundance of great models to work with at different performance speed cost tradeoff points. And your software factory lets you use all of them together. The best engineers now are building systems of agents. They're not

[00:02:00] debating which model is the best anymore. It's important, but it's less relevant every single day. Software factories are the system you use to scale your compute, to scale your impact. I've denoted the three actors of value creation. There's me, the engineer, there's the code that actually executes, and then we have our agent. So this isn't just about running a bunch of agents in parallel or in different team configurations. It's about combining engineers plus code plus agents at the right time to get the best results. Agents plus code beats agents alone. Your software factory depends on your ability to prompt engineer, context engineer, and of course, harness engineer. We can go up to the agent config. You can see all the tools, the coding agent we use, and the specific agent harness we used.

[00:03:00] This software factory is allowing me to do all the sub-engineering inside of agentic engineering — prompt engineering, context engineering, harness engineering, and what's inaccurately called loop engineering, which is really all about managing the software developer life cycle. But let's actually run our super simple software factory. I'm using Herder as my terminal multiplexer now, transitioned away from tmux. I'm going to fire up a Pi coding agent running Opus 5. A key feature of the super simple software factory is that it has agentic access — I could operate this myself with commands (plan, plan build, so on), but why would I when an agent can orchestrate the system on my behalf?

[00:04:00] Let's kick off a workflow: "break down what this app is, its features, and suggest three new features to enhance the application." We're using Opus 5, so it's going to write this prompt and kick off the workflow. This is observable in a live way — we're running a simple ADW scout workflow, starting simple and progressing to more complex prompts / AI developer workflows. We're running a single scout agent. It has enhanced my prompt to make it clearer and more concise.

[00:05:00] We have a simple two-phase workflow: request comes in, then a scouter agent runs — one engineer, one agent. We're running Gemini 3.6 Flash, a really cost-effective A-tier workhorse model at $1.50 in. I have a model stack tracking state-of-the-art, workhorse, and lightweight on-device models. I'm not fixating on one model anymore — it's about the model stack, and the software factory is how you get there. The scout agent finished — it just scouted the application (Inkwell, a writing app), presenting three proposed new features.

[00:06:00] Just scouting: finding information, presenting ideas — a really simple atomic unit of the software factory. Let's run a more advanced AI developer workflow. I've prompt engineered an orchestrator agent that presents all the workflows the factory has: simple prompt, scout, plan, build, quality check (lints, formats, type checks), documentation, and composite workflows (the heavy hitters that do the real work) — plan/build/test, plan/build/review/build/test, and the full ADW/SDLC.

[00:07:01] Let's run an intermediate step: add light mode to contrast the dark default, with a proper design system so we can add other themes later. This kicks off a three-step agentic workflow combining code and agents: plan, then build, using Kimi K3 (the first open-weights model to hit the state-of-the-art tier, though it "thinks a lot" so isn't as fast as Opus/Sonnet). Using it via Fireworks — fast/priority serverless tiers, US-only, addressing AI-model-ownership concerns (referencing a prior video on "is Anthropic stealing your data while you pay for it"). Not sponsored by Fireworks.

[00:08:00] Two agents completed the workflow — planner + builder. Result: clicking the light button correctly inverts the color scheme. The workflow included two code checks afterward to verify; if verification fails, the work gets sent back to the build agent to correct.

[00:09:01] A big idea engineers are going to miss: not everything needs to be agentic. Code costs nothing, runs at the speed of light, changes instantly — and you actually own your code, whereas you're renting your AI models.

[00:10:01] Code is a first-class citizen in the workflow. This is open-source and free (not selling a tool). The framing has scaled past single-agent and multi-agent orchestration into software factories — thinking not at the prompt level, not at the skill level, not even at the team-of-agents level, but at the full end-to-end developer workflow, then building THAT with agents. This is an AI developer workflow (ADW) — reproducible success over and over.

[00:11:00] Reusable, observable, customizable. Full observability of the plan step: system + user prompt, agent config. Deterministic gate checks (code) run at the end of the plan step, plus a cost breakdown per agent phase. Outputs hand off context via a shared directory (ADW sessions). Reads the essential pieces of the codebase, not all of it — the more you productionize something, the more you should understand what's happening.

[00:12:00] Agents output JSON that gets formatted and validated; if it fails, the agent must properly re-output. Determinism is wired into every agent step — specific types/structures required for consistency across hundreds/thousands of executions "without me." That's the core promise: a well-built software factory runs without you. The build step: compiled prompts show the task + the previous envelope (handoff from planner) with full context, task, and response report format (instructions, variables, workflow report).

[00:13:01] Keeps chaining outputs to the next agent, tracking changed files, tool calls. "If you don't measure it, you cannot improve it." Address engineer-incoming prompts directly, address code directly, customize the agent as needed. Code plus agents beats agents alone — engineers throwing everything into skills/agents will pay in mistakes, hallucinations, cost, speed, performance. Why pass successful passing tests back into an agent's context window when a deterministic path handles it?

[00:14:00] That's the line between vibe coding and agentic engineering. Scaling up: running the full SDLC on the Inkwell editor to add a side-by-side markdown viewer (togglable, covered with tests, "use the state-of-the-art configuration"). Every model/role/agent-harness/tool is customizable per step.

[00:15:00] Watching the agent boot the ADW SDLC — research, confirm the roster, kick off. Planner: Claude Opus 5 ("cracked," state-of-the-art — Dan gives his opinion that Fable 5 still feels better than Opus 5 despite benchmarks/price favoring Opus 5, invites comments).

[00:16:00] Opens VS Code (used only for code viewing/typing prompts). The whole system is wrapped in a single skill: SSSF (Super Simple Software Factory) — agents propose, code disposes; code always validates and controls the entire workflow. An ADWS directory holds the AI developer workflows end-to-end.

[00:17:00] The largest workflow (full SDLC) is ~180 lines of Python using with statements to denote phase entrance/exit: planning, commit plan, build, test (fix if something goes wrong), review/revise, document, commit docs. Clear separation of agents vs. code throughout.

[00:18:01] Every phase is an agent call to Dan's preferred coding agent (the "Pi coding agent"), fully configured. The "core four" for every agent: context, model, prompt, tools. "If you match the core four, you'll master the agent." Planner example: Kimi K3 via Fireworks, thinking high — system/user prompt (prompt engineering) + harness engineering (custom agent harness per agent).

[00:19:00] The builder follows the same pattern — specify tools, prompts, operation. Sub-agent support added to the planner and scouter so they can spin up their own sub-agents. Agentic access is one of five key pillars of agentic engineering: "if you're doing something you can teach your agents to do, why aren't you?" — build the system that builds the system.

[00:20:00] Walking the simplest ADW ("prompt"): takes inputs, runs the agent, validates via a phase class, calls into agent.py's run_workflow. Setting up the Pi coding agent with exact params (mode, JSON, provider). Deliberately "staying in distribution" — no custom DSL, just Python, YAML, agents, and a skill.

[00:21:00] Workflow finished — full model customization, cost analysis, full agent configuration, phased work (plan/build/review — one agent, one prompt, one purpose). Can restart from the session/ADW ID. Acknowledges gaps: currently running on main branch; production use needs a branch/sandbox and a merge step. Deterministic checks validate work at each step.

[00:22:01] Review step asks "is what we built what we asked for?" (Opus). Diffs changes to document work for the next engineer/agent. Not just torching tokens/token-maxing — designing for what the system needs to win over hundreds/thousands of runs, "the art and science of agentic engineering."

[00:23:00] Rebuilt this system for the "next phase of agentic engineering" — a new cohort of engineers stacking code + agents, with human-in-the-loop as a later design question. Validates the markdown side-by-side feature works (headers, lists, bullets all render correctly) — "these models are more than good enough to prompt this... you probably could have just thrown it in a single agent."

[00:24:00] At what scale do you need this? Not this scale yet, but "your system will get so large, so complex that validation will be the only way forward." Whether you hand that to an agent (expensive) or code (deterministic), you pay a cost somewhere — think about scale, production, standards, the thousandth run not the first.

[00:25:00] The system is packaged as a skill (SSSF) that teaches an agent how to operate and extend it, including deploying it into NEW codebases via a /install command that copies everything in. Fully reusable, designed to be deployed across codebases. Skill design pattern: a central idea (deploy/operate repeatable agents+code in any codebase) plus a "cookbook" of lazy-loaded, incrementally adoptable actions.

[00:26:02] The cookbook table routes requests: set up the factory in a new repo, create/modify an ADW, create config, set up a new agent roster, etc. — "agentic access," one of five pillars. "You are moving too slowly if you are doing pretty much anything by hand unless you're building the system that builds the system." Ships with templates for a first version; expectation is you customize tests/plan-quality/etc. to your own needs — it's atomic, not a fixed product.

[00:27:01] Leverage scales with effort/time/investment put into your ADWs (which make up your factory). "There's a ton of engineering work you just don't need to be doing anymore... so why are you?" Time to build your software factory, deploy to the cloud, set up sandboxes to push the 80% junk work off to the agent stack reliably, and focus on the real net-new hard work agents can't do without you. Free and open — "steal it, roll it into your own."

[00:28:00] "Vibe coding is not knowing how your system works and not looking. Agentic engineering is knowing how your system works so well you don't have to look." Plug for Tactical Agentic Coding course as the deeper resource ("for the top 20% of engineers").

[00:29:00] Also plugs a companion video on why "loop engineering" is a bad rebrand — the real concept is the software developer life cycle (SDLC), not loop engineering. "You know where to find me every single Monday. Stay focused and keep building."