A language-agnostic application migration pipeline powered by Claude Code. It takes any source code repository — regardless of language or framework — and produces a fully generated, tested, and evaluated target application in a different technology stack.
Nothing is hard-coded. The pipeline discovers:
- Source language — detected automatically by reading the source repo
- Target language and framework — determined by the documentation URLs you provide in
Reference_Links.md - Test framework — detected from the generated project's manifest file
- Claude Code CLI installed and authenticated
- A source repository placed inside this project directory
- A
Reference_Links.mdfile inside the source repo listing target framework documentation URLs
Place your source code folder at the project root:
Vibe Coding Migration Project v1/
├── YourApp/ # Your source repo goes here
│ ├── <source code> # Any language: VB.NET, Java, Python, COBOL, etc.
│ └── Reference_Links.md # URLs to target framework docs (see below)
└── ...
Inside your source repo, create a Reference_Links.md with documentation URLs for your target technology. The URLs determine what the app gets migrated to:
| Reference Links Point To | Target Stack |
|---|---|
| React / Next.js docs | TypeScript / React |
| Django docs | Python / Django |
| Spring Boot docs | Java / Spring |
| .NET / Blazor docs | C# / .NET |
| Go / Gin docs | Go |
| Rails docs | Ruby / Rails |
claude --system .claude/agents/orchestrator.md "Run pipeline on YourApp"That's it. The pipeline runs 3 phases automatically and produces a fully generated, tested repo at YourApp-<tech>/.
YourApp/
│
v
Phase 1: system-architect
│ Reads source code (any language)
│ Generates REDD (Reverse-Engineered Design Doc)
│ Generates TDD (Technical Debt Doc)
│ Generates ASD (Architecture Standards Doc) from Reference_Links.md
│ Generates DD (Design Document) combining all three
│ Evaluates each document for quality
│
v
Phase 2: frontend-developer
│ Reads the DD (which specifies target language/framework)
│ Generates full source code in the target stack
│ Creates YourApp-<tech>/ directory
│ Evaluates generated code quality
│
v
Phase 3: tester
│ Reads the generated repo
│ Generates unit and integration tests
│ Runs all tests, fixes failures
│ Produces test report and evaluation
│
v
Done — YourApp-<tech>/ is ready
Each phase runs in an isolated Claude session to avoid context window limits. State passes between sessions via handoff files in .claude/agents/handoff/.
If you prefer to run phases one at a time instead of the full pipeline:
# Phase 1 — Analyse source repo (generates REDD, TDD, ASD, DD + evals)
claude --system .claude/agents/system-architect.md "Run system-architect agent on YourApp"
# Phase 2 — Generate code from DD
claude --system .claude/agents/frontend-developer.md "Run frontend-developer agent on YourApp/DD_YourApp.md"
# Phase 3 — Generate tests for the generated repo
claude --system .claude/agents/tester.md "Run tester agent on YourApp-<tech>"Replace YourApp with your actual repo folder name and <tech> with the detected target suffix (e.g., typescript, python, java).
Skills can be triggered as slash commands inside a Claude Code conversation or via natural language:
| Skill | Slash Command | Purpose |
|---|---|---|
| redd-generator | /redd-generator |
Reverse-engineer design doc from source repo |
| tdd-generator | /tdd-generator |
Document technical debt from source repo |
| asd-generator | /asd-generator |
Architecture standards from Reference_Links.md |
| dd-generator | /dd-generator |
Design document from REDD + TDD + ASD |
| code-generator | /code-generator |
Generate code repo from DD |
| test-generator | /test-generator |
Generate tests for generated repo |
| Skill | Slash Command | Purpose |
|---|---|---|
| redd-generator-eval | /redd-generator-eval |
Evaluate REDD quality |
| tdd-generator-eval | /tdd-generator-eval |
Evaluate TDD quality |
| asd-generator-eval | /asd-generator-eval |
Evaluate ASD quality |
| dd-generator-eval | /dd-generator-eval |
Evaluate DD quality |
| code-generator-eval | /code-generator-eval |
Evaluate generated code quality |
| test-generator-eval | /test-generator-eval |
Evaluate generated tests quality |
You can also trigger skills by typing naturally in a Claude Code conversation:
"generate a REDD from the repo" -> redd-generator
"generate a TDD from the repo" -> tdd-generator
"generate an ASD from the reference links" -> asd-generator
"generate a design document" -> dd-generator
"generate code from the design doc" -> code-generator
"generate tests for the repo" -> test-generator
"evaluate the REDD" -> redd-generator-eval
"evaluate the TDD" -> tdd-generator-eval
"evaluate the ASD" -> asd-generator-eval
"evaluate the DD" -> dd-generator-eval
"evaluate the generated code" -> code-generator-eval
"evaluate the generated tests" -> test-generator-eval
When running skills manually, follow this order — each generator followed by its evaluator:
| Step | Generator | Evaluator |
|---|---|---|
| 1 | /redd-generator |
/redd-generator-eval |
| 2 | /tdd-generator |
/tdd-generator-eval |
| 3 | /asd-generator |
/asd-generator-eval |
| 4 | /dd-generator |
/dd-generator-eval |
| 5 | /code-generator |
/code-generator-eval |
| 6 | /test-generator |
/test-generator-eval |
| Target Language | Repo Suffix | Manifest File |
|---|---|---|
| TypeScript / Node | -typescript |
package.json |
| JavaScript / Node | -javascript |
package.json |
| Python | -python |
pyproject.toml |
| Java | -java |
pom.xml |
| C# / .NET | -csharp |
*.csproj |
| Go | -go |
go.mod |
| Rust | -rust |
Cargo.toml |
| Ruby | -ruby |
Gemfile |
The pipeline produces these files inside your source repo directory and the generated repo:
| Artifact | File Pattern | Example |
|---|---|---|
| Reverse-Engineered Design Doc | REDD_<App>.md |
REDD_MyApp.md |
| Technical Debt Doc | TDD_<App>.md |
TDD_MyApp.md |
| Architecture Standards Doc | <Tech>-ASD.md |
React-ASD.md |
| Design Document | DD_<App>.md |
DD_MyApp.md |
| Generated Repo | <App>-<tech>/ |
MyApp-typescript/ |
| Evaluation Reports | *_EVAL_*.md |
DD_EVAL_MyApp.md |
| Test Report | TEST_REPORT_<repo>_<date>.md |
TEST_REPORT_MyApp-typescript_20260325.md |
Vibe Coding Migration Project v1/
├── README.md # This file
├── CLAUDE.md # Pipeline instructions for Claude Code
├── execution_guide.txt # Quick-reference command list
├── .claude/
│ ├── agents/
│ │ ├── orchestrator.md # Launches all 3 phases sequentially
│ │ ├── system-architect.md # Phase 1 agent
│ │ ├── frontend-developer.md # Phase 2 agent
│ │ ├── tester.md # Phase 3 agent
│ │ └── handoff/ # Inter-agent state files
│ └── skills/ # 12 skills (6 generators + 6 evaluators)
├── <SourceRepo>/ # Your source code (read-only)
│ ├── Reference_Links.md # Target framework doc URLs
│ └── <generated docs> # REDD, TDD, ASD, DD written here
└── <SourceRepo>-<tech>/ # Generated output repo
├── src/ # Generated source code
├── tests/ # Generated tests
└── <manifest> # package.json, pom.xml, etc.
- Source repos are read-only — original source code is never modified
- No hard-coded secrets — use
.envfiles, never commit them (only.env.example) - Tests must pass — failing tests are fixed or skipped with documented reasons
- Discover, don't assume — languages and frameworks are detected at runtime, never hard-coded