The Software Factory Intensive

A two-day hands-on workshop for software engineers building autonomous, agent-driven development pipelines.

//2026 TOUR

Upcoming events

No dates are on the calendar right now. Join the waitlist to hear first when the next intensive is scheduled, or book a call to arrange a private workshop for your team.

Join the waitlist See previous trainings

//THE TRAINING

What the intensive covers

Every intensive follows the same two-day format, whichever city it lands in. Here is who it is for, what you leave with, and how the two days run.

//WHO SHOULD ATTEND

Built for engineers who ship

AI-enabled software engineers

Individual contributors who want to multiply their output and ship production-quality features at agent speed. You should be at Level 2 or above on the AI coding experience scale (already comfortable running coding agents in your IDE).

Engineering Teams

Teams looking to standardize on an AI-powered workflow that keeps humans in control without slowing down delivery.

Tech Leads & Architects

Leaders responsible for tooling decisions who need a clear-eyed view of what an AI software factory looks like in practice.

CTOs & Engineering Managers

Executives exploring how to reduce cost and compress timelines without sacrificing code quality or security.

//BENEFITS

What you'll walk away with

Ship in days, not months

Build systems and interfaces at a pace that was previously impossible, powered by an automated AI software factory you control.

Control your token spend

Configure and own an open-source software factory so you never hand over cost control to a black-box API. Pick the model that fits each job, or route tasks across several.

Agents that run 24/7

Deploy a multi-agent orchestrator to your cloud of choice and let 100+ coding agents work 24/7, long after you've closed your laptop.

//THE SHIFT

The new way to build

How Coding is Changing

Yesterday

Code is artisanal

Each line of code is written by hand

Today

Spec-driven development

Concepts and algorithms are written in English. Coder works directly with an agent to publish code.

Tomorrow

Autonomous development

The software engineer builds the software factory that can act as planner, designer, architect, SDET, coder, reviewer, and devops engineer.

SDLC → Factories

Always Has Been

Software Development Lifecycle

Software Development Lifecycle: the process of how we plan, build, test, and ship software. The discipline doesn't change.

Manual Development

Now Being Done As

Factories

Today, doing SDLC means building factories. The how has evolved: AI executes the lifecycle through orchestrated, spec-driven systems.

Agent-driven development

What Participants Learn

Learn 01

AI Coding

Prompting, iteration loops, memory, and AI-native workflow design

Learn 02

AI Agents

Multi-agent systems, orchestration patterns, and scaling to teams

Learn 03

AI Code Factories

Build the full factory: spec → design → code → test → review → deploy

//2-DAY WORKSHOP

How the two days run

In person, hands-on, and built around your own project. Day 1 lays the foundation; Day 2 goes deep with GasCity.

Length

Two days

2 day intensive · 8:00 AM both days

Format

In-Person

Hands-on workshop · bring your own project

Schedule

DAY 1Build the foundation

Breakfast

8:00 – 9:00 AM

What is a software factory?

9:00 – 9:45 AM

Get on the same page about why software factories matter, and make sure your laptop is ready for two days of hands-on work.

›Why this matters
›What it looks like
›Confirm your setup is good to go.

Make a factory

10:00 AM – 12:00 PM

Learn what every software factory needs so you can make your own ‘build versus buy’ call with confidence.

›The three parts of any factory: inputs, factory processes, and outputs.

Example · Acme Widgets · Upgrade from static to dynamic inventory

·Inputs: Requirements (ADRs & Beads).
·Factory processes: Skills and formulas that turn requirements into working code.
·Outputs: shipped software & living docs

Lunch

12:00 – 1:00 PM

Welcome to GasCity

1:00 – 2:00 PM

Intro to GasCity factories

2:00 – 3:45 PM

See how GasCity wires up the inputs, processes, and outputs. Learn enough to pick it up tomorrow and start building your own.

›An end-to-end tour of the GasCity approach.

Example · Acme Widgets · Upgrade from static to dynamic inventory

·Inputs: Use skills in GasCity to generate requirements
·Factory processes: sling the work and watch the factory complete it.
·Outputs: review what came out the other side.

Plan your factory

4:00 – 5:00 PM

Sketch out a plan for what to start building on Day 2.

DAY 2Go deep with GasCity

Breakfast

8:00 – 9:00 AM

How we work

9:00 – 9:45 AM

How the GasCity team builds GasCity with GasCity.

What GasCity Does Best

10:00 AM – 12:00 PM

See where GasCity shines so you can decide whether it’s the right tool for you now, or know when you need it.

Example · Demo 1: Meet the Mayor

·Use the Mayor to triage bugs and ship fixes.
·Customize your workflow (e.g. open a PR, run an ADR check, or gate releases on an external review).

Example · Demo 2 · Converge on a thorny tech problem (live)

·Watch the factory work through a real convergence problem alongside the facilitators.

Lunch

12:00 – 1:00 PM

What GasCity Does Best (cont.)

1:00 – 2:00 PM

Example · Demo 3 · A second gnarly tech problem

·Run through one more worked example so the pattern sticks.

Learn GasCity

2:00 – 2:45 PM

Get fluent in the GasCity primitives so you can recombine them on your own factory.

›Agents
›Skills
›Formulas
›Orders
›Packs
›Cities

Work on your factory

3:00 – 4:30 PM

Build something you can take home and keep using on Monday.

›Review and revise your plans from yesterday.
›Decide what’s worth shipping today.
›Build it. Extend the Day 1 examples, or roll your own with GasCity.

“Change your oil”

4:30 – 5:00 PM

Walk away with a clear view of your standardized vs. custom parts, and a stronger opinion on where training, consulting, or services would pay off most.

›Change your own oil: track your stack components as they move from one version to the next.
›Get your oil changed: how Actual writes ADRs and version-bump recommendations so you don’t have to.
›Exercise: which parts of your stack should be documented for your team and your factory?

//FAQ

Frequently asked questions

A production-ready software factory: a pipeline that takes a structured issue as input and executes planning, design, architecture, test generation, code generation, review, and deployment. The system is designed to run continuously and can be triggered programmatically.

A software factory is a composition of specialized agents, each responsible for a stage in the development lifecycle. Agents communicate via structured artifacts (manifests, specs, tests, code) and operate under shared constraints defined in your factory configuration.

You'll define your system via two generated artifacts: a Project Manifest (describes the product, domain, constraints, and goals) and a Factory Manifest (defines agent behavior, interfaces, and outputs). These are used to generate agent-specific configuration files that control execution across the pipeline.

You will customize six core agents: Planning, Design, Architecture, Testing, Code Review, and Deployment. For code generation, you can plug in your preferred coding agent (e.g., your existing LLM-based coding tool). This keeps the system flexible and allows you to swap in best-in-class generation models as they evolve.

Two days split into Workshops (live, guided sessions where an instructor presents from stage and everyone builds in parallel at the same pace) and Labs (hands-on sessions where you work at your own pace with facilitators available to unblock you). You'll be working directly on your own project throughout.

No. You should be comfortable with a software codebase, but we'll introduce the agent architecture, prompting structure, and system design patterns as part of the workshop.

The same system applies. For a solo developer, the factory acts as a force multiplier. For teams, it standardizes workflows, enforces architectural consistency, and reduces coordination overhead.

The workshop is structured around Gas City (successor to Gas Town), along with supporting tooling for agent configuration, context management, and pipeline orchestration. The system is designed to be extensible and not tied to a single vendor.

Yes. Seven days before the workshop, you'll receive a structured input form about your project. This is used to generate your initial manifests, so you start with a system already aligned to your codebase and requirements.

The factory captures outputs (code quality, test results, review feedback, deployment outcomes) and feeds them back into the system to update prompts, constraints, and agent behavior over time.

Most of these tools solve a single layer of the problem:

Coding harnesses (Aider, SWE-agent, Devika, OpenDevin) focus on the edit → run → fix loop
Execution runtimes (Open Interpreter, OpenClaw, TinyClaw) focus on tool use and environment control
IDE interfaces (Continue.dev) focus on developer interaction
Starters / stacks (Gstack) provide opinionated project scaffolding
Orchestrators / multi-agent frameworks (GasTown, Gas City, AutoGen, CrewAI, LangGraph, MetaGPT) coordinate agents and workflows

The factory you build in this workshop sits one level above all of these. It is a system that composes them:

You define the architecture of the pipeline (planning → design → architecture → test → code → review → deploy)
You encode behavior in manifests and context files (e.g. soul.md)
You plug in any coding harness or model you want
You run it as a continuous, end-to-end system, not a single agent loop

Next step

Want to know more about the workshops?

Book a call with John to talk through the format, how to prepare for a workshop, or to arrange a private workshop for your company.

Book a call

Your city is not listed?

Register your interest in Seattle, New York City, Los Angeles, or San Francisco, or choose the remote option to hear about an online cohort, and we will notify you as soon as dates are confirmed.

Join the waitlist

Want to sponsor the tour?

Put your brand in front of engineering leaders building AI-native software factories across five cities in 2026.

See the sponsor prospectus

View previous trainings →