Sign up for the
Software Factory Intensive
May 11th – 12thNew York CityIn-person
Event by
Hosted by
//SPEAKERS
Meet the instructors
//WHO SHOULD ATTEND
Built for engineers who ship
Software Engineers
Individual contributors who want to multiply their output and ship production-quality features at agent speed.
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.
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 Code 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
//WORKSHOP PLAN
Build Your Agent Factory
Development Pipeline
Step 01
Start a Project
What do you want to build?
Define your idea, goal, or problem. Your vision in plain language — what you want to build and why it matters.
↓
Step 02
Project Manifest
idea → structured intent
AI transforms your idea into a Project Manifest — goals, scope, constraints, roles, and success criteria. The living document that drives every factory decision.
↓
Step 03
Software Factory Spec
Project-specific SDLC blueprint
Generated from your manifest, specific to your project. Maps the full SDLC: workflow stages, agent roles, coding standards, quality gates, and deployment rules.
↓
Step 04
Building your Agent Factory
Agent Storage
Metadata that operates the factory
Test Cases
Unit, integration & E2E test templates
Perf Specs
Performance benchmarks & SLAs
Security Model
Access controls, trust boundaries, guardrails
Pricing Model
Token budgets & API cost thresholds
Agent Operation
The structural blueprint for ongoing agent operation
// Plan
Work breakdown
Create work packages for agents based on high level goals
// Design
UX systems
Create and update design systems. Deploy storybook demos.
// Architect
Rules for operation
Set and update architectural rules
// Validate
Test Cases
Validate acceptance criteria and build tests
// Build
Code
Generate code using artifacts and continual test output
// Review
Code Review
Automated review — style, security, and spec compliance
// Deploy
Release Gate
Quality gate — all checks must pass before shipping
// Improve
Feedback Loop
Runtime data feeds back into the spec and memory
//2-DAY WORKSHOP
Workshop details
Date & Location
Date
May 11–12
2 day intensive · 8:00 AM both days
Format
In-Person
Hands-on workshop · bring your own project
Location
New York City
Downtown · Exact venue shared with registered attendees
Schedule
DAY 1
Breakfast
8:00 – 9:00Coffee and light breakfast · Registration & check-in
Introduction
9:00 – 9:20Introducing the format and team
Foundation
9:20 – 9:50The Future of Software Factories
Orientation
9:50 – 11:00Factory Roadmap for Your Project
Workshop
11:00 – 12:00Run the 6-Agent Software Factory
Lunch12:00 – 1:00dietary needs accommodated
Workshop
1:00 – 1:45From Individual AI Workflow to Software Factory Pipeline
Lab
1:45 – 2:45Build a Structured Development Loop
Break2:45 – 3:00Help desk available
Workshop
3:00 – 3:45Architect Multi-Agent Coordination
Lab
3:45 – 5:00Deploy Planner + Architect Agents
Wrap-Up
5:00 – 5:30Factory Checkpoint & Day 2 Preview
DAY 2
Breakfast
8:00 – 9:00Coffee and light breakfast · Help desk open
Foundation
9:00 – 9:30From AI Assistants to Autonomous Delivery Teams
Lab
9:30 – 10:45Deploy Designer + Coder Agents
Break10:45 – 11:00Help desk available
Lab
11:00 – 12:15Deploy Reviewer + DevOps Agents
Lunch12:15 – 1:15dietary needs accommodated
Workshop
1:15 – 2:00Create Continuous Improvement Loops
Capstone Lab
2:00 – 3:30Run the Software Factory End-to-End
Break3:30 – 3:45Help desk available
Troubleshooting
3:45 – 4:45Facilitator-led factory troubleshooting
Closing
4:45 – 5:15From Workshop to Real Operating Model
Pricing
Regular
$900
Regular Price
Standard admission.
Group
$720
Group (5+)
Per person for teams of 5 or more.
Next step
Join the intensive
Reserve your spot, or 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