Matt Pocock - Software Factories for Real Engineers

ABOUT THE COURSE:

This course will teach you how to create your own AI-powered software development factory, where AI agents perform engineering tasks, write and verify code, fix bugs, and prepare changes for review. The program's primary focus is not on the haphazard use of AI tools, but on building a managed development system with architectural rules, automated checks, documentation, and quality control.

Over two weeks, you'll learn a practical approach to using AI agents in real-world development: from setting tasks and conveying context to automated testing, reviews, preparing pull requests, and improving an existing codebase.

The course helps transition from a model in which the developer constantly monitors the AI and corrects its errors to an engineering model in which agents operate within a clear process, adhere to project standards, and produce verifiable results.

What is an AI software development factory?

An AI software development factory is an organized system in which AI agents receive tasks, use project documentation and context, make changes to code, run checks, fix identified issues, and prepare the result for review by an engineer.

Unlike the typical use of a chatbot or terminal agent, Software Factory is built as a repeatable process. It pre-defined agent roles, codebase rules, quality criteria, constraints, automated checks, and human oversight points.

This approach is especially useful for teams and engineers who want to use artificial intelligence not only for rapid code generation, but also for sustainable product development, refactoring, legacy code management, and improving development quality.

Why the Standard Use of AI Agents Isn't Enough

Modern AI agents are capable of quickly implementing features, writing tests, fixing bugs, and suggesting architectural solutions. However, without an engineering system around them, they often create new problems: technical debt, inconsistent quality, unnecessary abstractions, and errors that must be found manually.

The main reason is that AI operates within a limited context. The agent may not consider the project's long-term architecture, business constraints, existing dependencies, team agreements, and hidden quality requirements.

Common problems when working with AI without a system

• Constant manual review. The developer spends a lot of time reviewing, correcting, and rewriting AI-generated code.

• The need for continuous monitoring. You have to monitor multiple agents, switch between tools, and constantly update the context.

• Cognitive overload. Managing agents becomes a complex task in itself, requiring almost as much attention as developing them independently.

• Inconsistent code quality. Rapid code generation can lead to duplication, poor architectural decisions, violations of standards, and increased technical debt.

• Inefficient spending. Repeated requests, failed attempts, and constant rework increase the cost of time, budget, and tokens.

The course addresses these issues as standard engineering tasks. They can be addressed through process architecture, automation, testing, documentation, coding standards, and properly organized controls.

What you will learn in the course

The program is built around the practical design of the AI Software Factory—a system that helps delegate real-world development tasks to agents and produce results suitable for further use in the project.

1. Designing your own Software Factory

You will understand the components of a software development factory with AI agents and how to link them into a single process.

• How to accept and formalize tasks for agents.

• How to convey project context to agents.

• How to organize task execution without constant manual support.

• How to enable automatic quality checks.

• How to adapt a factory to a team, project, and engineering standards.

2. Knowledge and project context management

The performance of AI agents directly depends on how well they understand the codebase, subject area, and project constraints. Therefore, a separate section of the course is dedicated to knowledge management.

You will learn how to create and maintain documentation that helps agents make more accurate technical decisions.

• Ubiquitous Language is a unified domain language for teams and agents.

• Map of the project and its architecture.

• Architecture Decision Records – recording architectural decisions.

• Technical specifications for tasks.

• Formalization of requirements and readiness criteria.

• Documenting components, dependencies, and constraints.

• Keeping your codebase knowledge up to date.

3. Developing standards for AI agents

You'll learn how to set rules for agents to follow when working on a project. This includes not only text instructions but also automated control mechanisms.

• Documenting development standards.

• Setting up linters and formatters.

• Static type checking.

• Automatic tests.

• Automated code review.

• Hooks and restrictions for agent actions.

• Checking the compliance of changes with the project architecture.

The goal of this block is to build a process in which quality is ensured by the system, and does not depend only on the developer's attention to detail.

4. Three levels of quality control

One of the key principles of the course is to first ensure manageability and quality, and only then scale the speed of agent work.

The first level is automatic checks

Tests, linters, type checkers, and other tools automatically find errors, standard violations, and regressions.

The second level is automated review

Additional analysis mechanisms, including AI-powered critical review, help identify issues that standard tools cannot detect.

Third level - review by an engineer

The developer is involved where human expertise is truly needed: when assessing architectural decisions, complex changes, risks, and compliance with business goals.

At the same time, the system must generate clear Pull Requests so that the engineer can quickly understand what was changed, why it was done, and what checks have already been passed.

5. Automation of engineering tasks

You will learn how to organize the work of agents so that they can perform tasks with minimal human intervention.

• Receive a task with requirements and completion criteria.

• Study the required part of the project.

• Plan for change.

• Write and modify code.

• Run tests and checks.

• Correct any errors found.

• Prepare the result for review.

• Notify when work is completed or when an engineer's intervention is required.

This process allows the developer to delegate clear tasks to agents and return to the prepared result, rather than manually controlling each action.

6. Working with an existing codebase

Software Factory is useful not only for creating new features. It can be used to systematically improve existing projects, including complex and legacy codebases.

• Refactoring complex sections of code.

• Eliminating technical debt.

• Improving the architecture.

• Optimization of components.

• Expanding test coverage.

• Finding and fixing errors.

• Improving the clarity and maintainability of the project.