Sign up for the
Software Factory Intensive
June 18th – 19thSan Francisco, CAIn-person
//SPEAKERS
Meet the instructors
//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
01
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.
02
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.
03
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, architect, designer, 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 DevelopmentNow 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 developmentWhat 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
Workshop details
Date & Location
Date
June 18–19
2 day intensive · 8:00 AM both days
Format
In-Person
Hands-on workshop · bring your own project
Location
San Francisco, CA
Exact venue shared with registered attendees
Schedule
DAY 1Build the foundation
01
8:00 – 9:00 AMBreakfast
02
9:00 – 9:45 AMWhat is a software factory?
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.
03
10:00 AM – 12:00 PMMake a factory
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
04
12:00 – 1:00 PMLunch
05
1:00 – 2:00 PMWelcome to GasCity
06
2:00 – 3:45 PMIntro to GasCity factories
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.
07
4:00 – 5:00 PMPlan your factory
Sketch out a plan for what to start building on Day 2.
DAY 2Go deep with GasCity
01
8:00 – 9:00 AMBreakfast
02
9:00 – 9:45 AMHow we work
How the GasCity team builds GasCity with GasCity.
03
10:00 AM – 12:00 PMWhat GasCity Does Best
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.
04
12:00 – 1:00 PMLunch
05
1:00 – 2:00 PMWhat GasCity Does Best (cont.)
Example · Demo 3 · A second gnarly tech problem
- ·Run through one more worked example so the pattern sticks.
06
2:00 – 2:45 PMLearn GasCity
Get fluent in the GasCity primitives so you can recombine them on your own factory.
- ›Agents
- ›Skills
- ›Formulas
- ›Orders
- ›Packs
- ›Cities
07
3:00 – 4:30 PMWork on your factory
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.
08
4:30 – 5:00 PM“Change your oil”
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?
Next step
Join the intensive
Registration opens soon. In the meantime, explore sponsorship to put your brand in front of engineering leaders building AI-native software factories.
//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