Stuck Building Your Factory?Pilot in Weeks

A working AI software factory, built around your code, run by your team.

We stand up the full pipeline around one of your existing projects, ship real PRs through it, and train your engineers to operate it long after we're gone.

Built around one of your real projects, not a toy demo
Specs, agents, guardrails, and CI wired into one operating model
Your engineers trained hands-on by the team that runs ours
Yours to own, extend, and re-point at the next project

Scope My Pilot

Problem

Software factories don't ship themselves

The patterns are still being invented. The agents are good, but they don't come pre-wired into an SDLC. Most teams who try to build a factory in-house stall at proof-of-concept — clever workflows on a laptop, nothing shipped from a real pipeline.

eng-portal · internal-initiatives

Initiative · #SF-0042

Internal Software Factory Build-Out

Stalled

Status

Stuck at POC

Days since kickoff

127

PRs shipped via factory

Stage status

Planner
Spec drift
Manifests handwritten by 3 different teams. None match the code.
blocker
Architect
No shared rules
Each agent picks its own conventions. PRs contradict each other.
concern
Coder
IDE-only
Agents only run on a developer's laptop. Nothing autonomous.
blocker
Reviewer
Skipped
Quality gates not wired. Style and security drift PR over PR.
concern
DevOps
Manual
Deploys still hand-rolled. No way to ship at agent speed.
blocker

The patterns move every quarter

Anything you architect today will be rebuilt in six weeks. Teams keep restarting from scratch.

IDE-bound agents don't scale

A coding agent on a developer's laptop isn't a factory. Real throughput needs an orchestrator, gates, and shared state.

Specs, agents, and gates drift apart

Without one operating model, each piece evolves on its own. PRs contradict each other and quality slips.

Your team has never run one

Multi-agent operations is a new discipline. Hiring for it is hard. Reading blog posts about it doesn't transfer to your codebase.

Solution

We build the pilot. Around your code. With your team.

One engagement, one pilot project. We assemble the factory on top of your existing codebase, ship real PRs through it, and train your engineers to run and extend it. You finish the engagement with a running factory and the team who knows how to operate it.

A factory around your codebase

We point the pipeline at one of your existing projects and stand up the full SDLC — planner, architect, designer, coder, reviewer, devops — wired to your repo, CI, and cloud.

Project Manifest & Factory Spec

Living documents that capture your project's intent and translate it into a factory configuration tailored to your code, stack, and quality bar.

Working PRs, not slideware

The pilot ships a real slice of work through the factory: PRs against your repo, gated by your engineers, on your CI. No demo videos — actual merged commits.

Agent operating model

Documented agent roles, prompts, guardrails, gates, and feedback loops. Your team can add agents, swap models, and adjust gates without rebuilding the factory.

Hands-on staff training

Workshops and pairing sessions for the engineers, leads, and managers who will operate the factory. They leave running it without us in the room.

Yours to keep

The factory, the specs, the configs, and the operating handbook live in your repo. Re-point it at the next project without a new engagement.

Pipeline

The pipeline we build for you

The same factory pipeline we teach in the Software Factory Intensive, tailored to your codebase and stood up inside your environment. Idea → manifest → spec → factory, with agent storage and operation cleanly separated.

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

CORE BUILD PHASE

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

Use Cases

Where the pilot fits

The same operating model adapts to very different shapes of work. These are the engagements we've found work best for a first pilot.

New Projects

Greenfield

Stand up a brand-new service or product with the factory in place from day one. Spec, agents, guardrails, and CI assembled before the first line of code.

›Internal tools and admin apps
›New customer-facing services
›Greenfield mobile or web products

Refactoring

Cleanup

Point the factory at a sprawling codebase. Agents propose, review, and ship refactor PRs in batches — with humans in the loop on every gate.

›Untangling monoliths into modules
›Standardising patterns across teams
›Killing dead code at scale

Modernization

Stack uplift

Move a legacy codebase onto a current stack one slice at a time. The factory enforces parity, runs the test suite, and keeps the lights on.

›AngularJS → React, Java 8 → Java 21
›.NET Framework → .NET 8
›On-prem services → containerized workloads

Migration

Cross-platform

Cross languages, frameworks, or cloud providers under a controlled, repeatable pipeline. The factory tracks coverage and flags risky moves for human review.

›Python → Go services
›Rails monolith → polyglot microservices
›AWS → GCP, or on-prem → cloud

Continuous Improvement

Ongoing

Keep a healthy codebase healthy. The factory runs ongoing review and refactor loops in the background between feature work.

›Dependency upgrades & CVE patching
›Test coverage uplift
›Performance and observability hardening

Legacy Triage

Knowledge recovery

For codebases nobody understands anymore. The factory extracts behaviour into specs, builds tests around it, and produces a living architecture map.

›Reverse-engineering undocumented services
›Capturing tribal knowledge as specs
›Rebuilding test suites from production traces

Training

Trained operators, not trapped customers

The pilot is only successful if your team can run the factory after we leave. We deliver hands-on training tracks tailored to engineers, leads, and leadership — paired with operating handbooks that live in your repo.

For Engineers

Operate the factory day-to-day

Add and tune agents in your pipeline
Author and update Project Manifests
Wire new gates and guardrails into CI
Triage and unblock stuck agent runs

For Tech leads & architects

Own the factory's design

Map your SDLC onto the factory spec
Set the coding standards agents enforce
Decide what humans review and what ships
Evolve the factory as the stack evolves

For Engineering leadership

Run the program

Measure factory throughput and quality
Control token spend and model routing
Plan the rollout to additional projects
Communicate the model to the rest of the business

Need to upskill a whole team before the pilot kicks off? Pair the engagement with the Software Factory Intensive so your engineers arrive ready to ship.

Process

From discovery to running factory

Five concrete steps. No mystery. The pilot ends with a factory that has already shipped a real slice of work — and a team that ran the last few PRs without us.

Discovery call

45 minutes to pick the right project, understand your stack, and agree the slice of work the pilot will ship through the factory.

Project Manifest

We turn your project's intent into a structured manifest — goals, scope, constraints, roles, and success criteria. The living document every factory decision rolls up to.

yaml

# PROJECT_MANIFEST.yaml
name: checkout-service
goal: migrate Rails monolith → Go services
constraints:
  - zero downtime
  - parity test suite must pass

Software Factory Spec

From your manifest we generate a factory specification tailored to your codebase: workflow stages, agent roles, coding standards, quality gates, and deploy rules.

yaml

# SOFTWARE_FACTORY_SPEC.yaml
agents: [planner, architect, designer, coder, reviewer, devops]
gates:
  - spec compliance
  - security review
  - human approval on merge

Pilot build & first PRs

We stand up the factory in your environment and ship the agreed slice of work through it — real PRs against your real codebase, gated by your engineers.

Training & handoff

Hands-on training for your engineers and leadership. They leave able to add agents, adjust gates, and run the factory without us in the loop.

Engagement

One pilot. One scope. Yours to keep.

Each pilot is custom-scoped against your project, stack, and team shape. We'll size it on the discovery call and agree the slice of work the factory will ship before kickoff.

Engagement commitments

Pilot scoped to one project and one agreed slice of work
Factory built in your repo, your CI, and your cloud
Project Manifest + Software Factory Spec checked in
Real PRs shipped through the factory before handoff
Staff training sessions for engineers + leadership
Operating handbook and runbooks delivered with the factory
Re-usable: re-point the same factory at the next project

Run your first real factory this quarter

Tell us which project you'd point the pilot at. We'll come back with a scope and a kickoff date.

Scope My Pilot