A PLAN FOR AN AI + HUMAN DEV FACTORY

FORGE
tasks in, tested software out.

A software factory where AI agents do the building and the testing, and humans stay on the wheel. The same loop that ships your product today — drawn out, stage by stage, on the real UI it already runs on.

Bug & feature tickets in Proven, shipped software out 🤖 AI on the pedals  ·  🧑‍✈️ Human on the wheel
An isometric dev factory: AI robot arms build and test code on a glowing conveyor while human engineers review and approve from a glass control booth, wrapped in a continuous improvement loop.
THE IDEA

One queue in. One loop. Proven software out.

Every bug report and feature request enters a single backlog. An AI agent picks up a task in its own isolated copy of the app, diagnoses it against the real code and everything the factory has learned, writes the fix, and proves it with a measured screenshot it checks itself. A human then reviews the diff and the proof and approves the ship. Nothing reaches customers without a person’s sign-off — and nothing reaches a person without proof attached.

THE LOOP

Six stages. AI builds & tests, humans steer.

It’s a loop, not a line — every shipped fix teaches the factory, so the next one is faster.

1
IntakeTickets land in one backlog; a human sets priority and the factory pulls the next card.
AI + HUMAN
2
DiagnoseAn agent reads the real code + its memory of past bugs and names the root cause.
AI
3
BuildThe same agent writes a minimal, explained patch in an isolated dev instance.
AI
4
ProveIt self-tests with a measured PASS/FAIL screenshot it reads back to confirm.
AI
5
ReviewA human reviews diff + proof and approves the ship — or sends it back with a note.
HUMAN
6
Ship & LearnMerged testing→live behind sign-off; the lesson is saved to memory.
AI + HUMAN
WALKTHROUGH

The same loop, on the real product.

These six mockups are built from real screenshots of the live product — the Alt-Y AI assistant and the IDsys Online data grid — annotated to show what happens at each stage. The bug in the story is a real one: a case-sensitive join that silently drops rows.

STEP 01

Intake — a task enters the line

A user reports missing rows in the Purchase Order grid. The ticket lands in the backlog; a human sets priority and the factory pulls the next card.

Step 1 — Intake: the IDsys Online grid with a task ticket callout.
Open full-size ↗
STEP 02

Diagnose — the AI finds the root cause

An agent opens the real code inside its own dev instance, recalls similar past bugs from memory, and explains in plain language why rows go missing: a case-sensitive join.

Step 2 — Diagnose: the Alt-Y assistant explaining the case-sensitive join.
Open full-size ↗
STEP 03

Build — the AI writes the fix

The same agent implements a minimal patch — normalising both sides of the join — and walks through the change line by line so it’s reviewable in seconds.

Step 3 — Build: the Alt-Y assistant showing the code fix.
Open full-size ↗
STEP 04

Prove — self-test with a PASS screenshot

Before it says “done,” the agent drives the real page headlessly, measures the result, stamps a PASS/FAIL overlay onto its own screenshot, and reads it back. No green pill, no ship.

Step 4 — Prove: the grid with a measured PASS proof overlay.
Open full-size ↗
STEP 05

Review — a human at the wheel

A person sees the diff and the proof side by side, sanity-checks scope and risk, and approves the ship — or bounces it back with a note. AI on the pedals, human steering.

Step 5 — Review: a human review/approve ship gate over the grid.
Open full-size ↗
STEP 06

Ship & Learn — out to live, lesson saved

The approved change flows testing → live behind the sign-off, and the agent writes the lesson to persistent memory — so the next bug of the same shape is solved in seconds.

Step 6 — Ship & Learn: the release pipeline and a memory-saved card.
Open full-size ↗

Why this example is real. The walkthrough isn’t invented UI — it’s the live Alt-Y assistant and the IDsys Online data grid, annotated. The bug is a genuine one the factory has fixed before: a CASE … LIKE join with a collation mismatch (utf8mb4_general_ci vs utf8mb4_unicode_ci) that silently drops rows. The fix — EF.Functions.Collate(...) on the merged columns — is exactly the kind of patch an agent builds, proves, and ships in this loop.

THE NAME

Why “FORGE”

A forge is where raw material becomes a finished tool under a craftsman’s hand and real heat — fast, but never unattended. That’s the pitch: machine speed, human judgement. Short, ownable, reads well on a hero. A few alternatives I considered:

FORGE ✓ Foundry Tandem The Loop Atelier Relay Cadence