software factory explained by a Senior Engineer (step by step)

Summary

The video explains an agentic software factory: a system of AI agents that handles routine work across the software development lifecycle, allowing engineers to focus more on architecture, quality controls, and higher-level decisions. The central shift is from manually building each product feature to building and improving the “factory” that produces features.

How the factory works

The example system uses a monolithic frontend and several backend microservices, with work tracked in GitLab and Linear. Its pipeline includes:

1. Triage agent: Collects bug reports from sources such as Slack, Sentry, or users, then checks whether reports are genuine, duplicated, or already fixed.
2. Refinement agent: Investigates and attempts to reproduce bugs, estimates scope and impact, and creates detailed tickets with acceptance criteria, screenshots, and Playwright recordings. Cypress and Playwright are used to inspect and reproduce behavior.
3. Prioritizer: Determines which tickets are ready to address, which are important, and which need human judgment.
4. Execution agent: Implements straightforward changes using project guidance such as CLAUDE.md, framework-specific skills, MCP-connected tools, and subagents. The guidance covers the design system, APIs, caching, databases, and other stack conventions.
5. Quality and release pipeline: Runs automated checks, testing, review, and staging validation before changes reach production.

The engineer says this setup can be built with commonly available cloud and AI subscriptions; it does not require a specialized lab or an unlimited token budget.

Quality controls and review

The speaker emphasizes that AI-generated code needs stronger, more deterministic checks because agents can produce large amounts of code and make inconsistent mistakes. Their safeguards include:

• Linters, TypeScript, and static analysis with Fallow to find duplication and excessive complexity.
• Automated cleanup checks, since agents may leave unused endpoints, tables, or other dead code.
• End-to-end tests in realistic environments, which the speaker finds more reassuring than relying mainly on unit tests or TDD for rapidly changing code.
• Screenshots and video comparisons in pull requests, enabling visual review without reading every line of generated code.
• A hard limit of 100 agent iterations before escalation to human review, preventing agents from looping and wasting time or tokens.
• An independent AI reviewer that looks for architectural regressions, boundary violations, redundant state, duplicated logic, and poor data modeling.
• Staging smoke tests for critical flows, followed by a QA agent that tests the feature from a user’s perspective.

The speaker reports having about 950 end-to-end tests in the full suite, which they say is expensive to run for every change. They therefore run a smaller, critical subset as smoke tests during releases. Their workflow typically produces 10–20 pull or merge requests per developer per day.

Human review is based largely on the change’s blast radius: small, isolated changes may be auto-merged, while database, design-system, or broader architectural changes receive closer scrutiny.

Engineering mindset and future direction

The engineer’s main advice is to fix the factory, not just an individual code issue. When agents repeatedly make a mistake, engineers should investigate whether the problem lies in missing context, code structure, or the pipeline itself. They can then encode the lesson into rules, skills, architecture, or tests.

The speaker sees AI as shifting work away from routine implementation and toward experimentation, system design, and judgment. They argue that engineers still need strong fundamentals—especially architecture, algorithms, APIs, cloud technologies, and testing—and that poor-quality “vibe-coded” software risks eroding user trust.

Potential next steps include routing tasks to cheaper or more powerful models, adding agents for documentation and change lists, improving feature-flag practices, and using formal verification to encode high-level rules that implementations must obey. The speaker also advocates for modular, observable, agent-friendly codebases with clear boundaries and reproducible test environments.

Guide and analysis covered

The video provides a high-level, step-by-step overview of building an agent software factory, including its agents, tools, safeguards, release process, and engineering implications. It also analyzes how the engineer’s role may change: less time writing routine code and more time designing systems and ensuring quality. A deeper walkthrough of each component is proposed for a possible follow-up video.

Main speakers

• Bogdan: The senior engineer describing his team’s software factory and engineering practices.
• The interviewer/host: Asks questions about the system, quality pipeline, and changing engineering skills.