Independent client work / Applied AI engineering · April 2026
Designing an autonomous migration factory
Generating a replacement function was only part of the job. I wanted a process that could continue through migration work without needing me to direct every individual step—and that could distinguish a plausible output from a checked result.
- My role
- Designed, implemented and operated the pipeline
- Delivered
- A working pipeline, a partially validated migration pilot and operating instructions
- Boundary
- Cloud test-environment validation, not a completed production migration
The problem
The client had a legacy PHP backend alongside a newer application. Responsibilities were split between old and new services, making authentication, integration and further development difficult. The migration needed a dependable way to preserve existing behavior.
I designed and built a Laravel-to-Supabase pipeline around coding agents, from inventory and prioritization through implementation and verification. The client is unnamed. This account describes the architecture and pilot rather than publishing the client's source code.
One endpoint at a time
The unit of work was one endpoint, including its variations and callers. The pipeline gathered the relevant source, described the expected behavior and prepared test cases before generating the replacement.
Expected results came from the existing code and responses from the running backend. Old and new implementations used the same inputs and expected outputs. The objective was behavioral equivalence, rather than an opportunity to redesign the product.
I tried processing larger groups together, but found that the additional context made the process harder to control. I chose smaller units even when that repeated work and used more model tokens.
Autonomy concerned progression, not just code generation
I configured the workflow to advance through the migration steps automatically, using the recorded stage and the results of review and checks. A coding agent's own completion message was not enough to accept the work.
Independent agents reviewed key artifacts and sent incomplete work back for revision. Executable checks exercised the implementation locally and, for the pilot, in a cloud test environment. The workflow also tested affected user flows with Playwright.
Each stage recorded progress in Markdown logs so interrupted work could resume from its recorded state. I was the sole human operator. Autonomous progression did not require concurrent migration workers; parallel execution was outside this pilot's scope.
What was delivered
I handed over the working pipeline, pilot functions and operating instructions. The work included local verification and validation in a cloud test environment.
The pilot did not reach production. I do not know whether the client continued using the factory afterward. The wider endpoint inventory was the scope to be worked through, not a count of completed migrations.
What I learned
The central design problem was not generating more code. It was connecting scope, usable context, review and execution into a process that could continue without my instruction at every step.
The same exercise also made a limit visible: a successful output at one stage is not proof that the entire application has been migrated. Acceptance has to correspond to the work actually checked.
Retrospective architecture account, updated October 2026. The original source and test logs are not published here; the description is not a byte-for-byte recovery of the final implementation.