Effective Software Factories Workshop

A hands-on, two-day workshop in which you build a quality pipeline: the component of a software factory that drives AI coding agents through writing, review, adjudication, and planning, so you get the quality you need along with the productivity you want.

Want to attend a public workshop? We don't have one on the calendar at the moment—email us and we'll let you know as soon as we schedule the next one.
Bring it to your team (in-house) — we run the workshop on-site, tailored to your codebase and stack. Email us or call (925) 918-1769.
Not sure yet? Start with a free lunch & learn for your team. Email us to set one up.

AI coding agents now produce changes faster than anyone can review them, and your attention has become the bottleneck. “Vibe coding” may work for a quick prototype, but it doesn’t hold up for software that must stay correct, maintainable, and reliable over time. The answer the industry is converging on is the software factory: a program that runs the show and calls AI agents as a service, with a process around them that lifts you out of the details without taking you out of the loop.

What makes a software factory effective is its review process. In this workshop you build your own factory around a quality pipeline that works through a roadmap one step at a time, each step passing through distinct phases:

Write. A model implements the next step from a written brief.
Review. Other models, not the writer, each read the changes in their own git worktree, run the tests, and report findings in a format your program can consume.
Adjudicate. Another model rules on the findings: what gets fixed and what doesn’t.
Re-review and re-adjudicate. The fixes face the same scrutiny.
Plan. A planner updates the roadmap, adding work discovered by building, possibly reordering what’s left. The pipeline then loops to the next step.

A manager agent decides when the run needs you. As the pipeline runs, agents record questions for you along with provisional answers, and keep going; the manager surfaces the ones you most need to see and tells you where the run stands. When a run finishes, the work goes up as a pull request and through your usual process.

What you’ll build, and learn

The workshop runs as a series of modules, each adding one piece to a factory that already works:

Sandboxing. Give agents a small enough blast radius that you can let them run unattended, even overnight.
The loop. What makes a loop agentic, and why your program, not the model, should decide when a step has passed.
Writer, reviewer, adjudicator. LLM-as-judge, its failure modes, and why reviewers need a schema and an adjudicator.
Evals. How you find out whether your review process is worth the tokens it costs.
The manager. Questions for the human, provisional answers, and steering a run without stopping it.
Planning. Letting a planner revise the roadmap as the code reveals what the plan missed.
The improvement loop. Proposing a change, measuring it against an objective, and keeping or reverting it, to improve the factory itself.

Each module starts with a short talk; then you build that piece with AI, and we look together at what was built and discuss what worked. Different prompts and different models give different outcomes, and comparing them is much of the point. The intructors circulate throughout the hands-on sessions to help you past the bumps.

Build your factory in whatever language you prefer. You can use your own AI coding agent subscription, such as Claude Code or Codex, or connect to open-source models through OpenRouter. You’ll leave with a working quality pipeline in your own repo, to keep using and improving, and new insight into how best to build software in the era of AI coding agents and software factories.

Who it’s for: Developers who already use AI coding agents and want more from them
Length: Two days
Format: In-house at your office, or as a public workshop

To bring this workshop to your team, email us at info@artima.com or call (925) 918-1769.