From prototype repo to production. Product and UX ship the code.
PointFive's product team designed new screens in a prototype repo with no production data, and production could not keep up.
We built a factory to close the gap, then handed the keys to the people with the product vision.
- BEFORE
Every feature was built twice. Once in a prototype repo, once in production.
- WHAT WE BUILT
A Frontend Delivery Factory: a design system, a gate, agent-written tests and migration skills.
- AFTER
Product and UX ship to production. Human review is no longer a bottleneck.
Every feature was built twice.
“Take this mockup and make it production” was the ask from PointFive's co-founder. Product designed in a prototype repo, then R&D rebuilt the same feature in production.
A moving target
Tens of pages and tables needed a new design system, while the prototype repo kept changing.
UI coupled to logic
Several UI libraries in one monorepo, and no single design system or standard.
Tests that missed
Client tests that did not test real behavior, and a dev environment that was hard to set up.
Four steps, in order.
Map the gap, make the standards impossible to skip, turn the migration into skills, then hand the skills to the people with the product vision.
- STEP 01DIAGNOSE
Before we changed any code.
- Mapped the monorepoIts UI libraries, and every place UI code was coupled to logic.
- Found the real gapThe prototype repo invented data structures the production backend did not have.
- Mapped the flowHow features moved from product to R&D, and where that flow broke.
- STEP 02LAY THE RAILS
Make the standard way the only way.
- A new design systemRebuilt from scratch, together with PointFive's team.
- Standards in codeOxfmt linter and formatter rules for the new design system.
- A gateCode that does not meet the standards cannot enter production.
- A generated schemaThe backend schema, generated into the Frontend, so a whole class of bugs cannot occur.
- Agent-written testsA new Playwright test setup, with an agent that writes the tests.
- Docs for the agentsThe codebase documented in
CLAUDE.mdand indexed for the coding agents.
- STEP 03BUILD THE FACTORY
Skills that do most of the work.
A skill is a written procedure that a coding agent follows.
- Migration skillsThey move pages from the prototype repo into production. Each skill has its own tests.
- A preview per branchA preview environment for every branch, for manual QA.
- The loop foundationThe base for a nightly self-improvement loop. PointFive's team then built the loop on top of it.
- STEP 04HAND OVER THE KEYS
Product and UX ship to production.
- UX runs the skillsPointFive's UX designer ran the migration skills herself and got production-grade results.
- A PR-risk classifierIt rates the risk of each PR. It is cheap, and the team trusts it to decide where human review is needed.
- No review bottleneckCode quality and conventions belong to the gate. Human review is no longer a bottleneck.
How a Frontend change reaches production.
Product and UX open the PR, and the rails check it. The PR-risk classifier decides where a person must look, so human review is no longer a bottleneck.
- Product and UXOpen the PR themselves
- Frontend PR on the production repoUI, UX and feature logic on existing APIs
- Automatic checks
- The gate
- PR-risk classifier
NO REVIEW BOTTLENECK - Production
- New data
- New APIs
- Architecture changes
The factory learns every night.
PointFive's team built a learning loop on top of the factory. Each night, it turns the day's corrections into rules.
- PRs mergeCorrections are in the commits
- Nightly loopReads the day's PR commits, plus a Notion log of every corrective prompt to Claude
- New lint rules and SDK changesThe day's corrections, made permanent
- Next PRsFollow the new rules
- EVERY NIGHT
Live in production. The standards hold.
Human review is no longer a bottleneck.
The gate checks every PR. The PR-risk classifier decides where a person must look.
We thought this project would be much harder and more complex. It converged pretty fast.
The new Frontend is live.
Production now runs on the new Frontend code.
Tens of pages and tables moved to the new design system.
The migration skills moved them from the prototype repo into production.
Product and UX ship Frontend code.
PRs from product and UX merge into the production repo.
Every line meets the standards.
The gate blocks code that does not meet the standards, and the nightly loop adds new rules.
Frontend review is no longer a bottleneck. Backend is next.
The gate and the nightly rules check every Frontend PR, and the PR-risk classifier decides where a person must look. PointFive's next goal is the same for backend PRs.
- FRONTEND · TODAY
Human review is no longer a bottleneck
The gate checks every PR. The PR-risk classifier decides where a person must look.
- BACKEND · NEXT GOAL
Backend PRs, the same way
Reviewed by developers today. The goal is what Frontend has now.
Your product team has the vision.
Give them the keys.
The assessment looks at where your delivery hours actually go, and what it would take for the people with the product vision to ship it themselves.
Get a Factory AssessmentBring one spec from your backlog.
Tell us where delivery is stuck: the queue behind your team, the review load, the AI output nobody can safely merge.
We audit the repo and the workflow, then run one real roadmap item through the pipeline, so you judge the factory on shipped code and not on our slides.
- 01
You send the form.
Your stack, your team size, where delivery jams.
- 02
We reply within a day.
A short call to see whether the factory fits.
- 03
We scope the assessment.
Repo, workflow, and the first feature to pilot.