# My Super Simple Software Factory (For Agentic Engineers)

## Executive summary

The video introduces the concept of a 'Software Factory'—an advanced system for agentic engineering that moves beyond relying solely on autonomous agents. The core thesis is that combining **Agents + Code** provides significantly more leverage and reliability than agents alone. This factory automates the entire Software Development Life Cycle (SDLC) by integrating deterministic code checks, ensuring repeatability, observability, and scalability across complex AI developer workflows.

## Key takeaways

- Agents Plus Code is Superior: The most significant advancement in agentic engineering is the combination of agents with explicit, deterministic code. This structure ensures reliability, cost control, and verifiable output, mitigating risks associated with pure AI orchestration.
- Three Core Design Principles: The Super Simple Software Factory is built on three non-negotiable principles: **Observable** (full visibility into every phase, prompt, and cost breakdown); **Customizable** (using a single YAML config to control the core four elements: context, model, prompt, tool); and **Reusable** (deployable across any codebase via an `/install` command).
- Scaling Compute for Impact: The system is designed to scale compute power by orchestrating complex, multi-step workflows (e.g., Plan $ ightarrow$ Build $ ightarrow$ Test $ ightarrow$ Review) that operate without constant human intervention.

## Technical details

- Architecture and Workflow: The factory implements a full SDLC workflow (ADW), which is structured using deterministic code checks. Phases are clearly separated, ensuring that outputs from one agent step (e.g., planning) are validated by the code before being passed as context to the next agent (e.g., building).
- Model and Tooling Stack: The system supports multiple models for optimal performance/cost trade-offs, including Gemini 3.6 Flash (cited as a cost-effective workhorse), Opus 5, and ChemK 3. The ability to select the 'right model at the right cost' is central to scaling compute.
- Configuration Management: Agent customization relies on mastering the 'core four': Context, Model, Prompt, and Tool. The configuration is managed via YAML files, allowing for specialized agent harnesses (e.g., adding sub-agent support to a planner).
- Development Workflow Structure: The underlying code structure uses Python `with` statements to delineate and enforce the boundaries of distinct work phases (e.g., planning, requesting, building), ensuring clear handoffs and validation points.

## Practical implications

- Engineers can build highly reliable, repeatable AI developer workflows that operate at 'agentic speed' without constant manual oversight.
- The system allows for the isolation of agent runs (e.g., running in a sandbox) and includes deterministic checks to validate work before proceeding, significantly improving production readiness.
- It shifts the engineering focus from prompt-level or skill-level design to designing the entire end-to-end developer workflow.

## Topics

Agentic Engineering, Software Development Life Cycle (SDLC), AI Developer Workflows, Build Automation, Prompt Engineering, Super Simple Software Factory repo, Tactical Agentic Coding (TAC)

Source: https://www.youtube.com/watch?v=haUfb1ievTE