code-porting

Port code between codebases through extraction, critique, and gated implementation.

Updated May 4, 2026
One-click install
npx skills add https://github.com/xaionaro/.config-codex --skill code-porting
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: code-porting
Source: https://github.com/xaionaro/.config-codex/tree/main/skills/code-porting
Command: npx skills add https://github.com/xaionaro/.config-codex --skill code-porting

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Port code between codebases through exhaustive extraction, adversarial critique, and gated implementation. Keep each phase as a separate work product. Use standard spawn_agent subagents when higher-priority Codex instructions allow delegation and the user explicitly requested subagents, parallel agents, delegated work, or dedicated agents. Do not launch Codex agents through shell wrappers.

Core Features & Use Cases

  • Exhaustive feature extraction from source projects to inventory capabilities and interfaces.
  • Adversarial critique loops to identify gaps against target codebases and propose validated porting plans.
  • Gated, phase-based implementation using per-task exploration, critique, and integration checks.
  • Use Case: Port a subsystem or capability from one project to another while preserving semantics and performance.

Quick Start

Port a concrete feature from SourceRepo to TargetRepo by generating an end-to-end porting plan and executing it through the explore-critique-implement loop.

Frequently Asked Questions about code-porting

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I port a subsystem from one codebase to another while preserving semantics?

Porting code requires structured feature extraction to inventory capabilities, an adversarial critique loop to validate the porting plan against the target, and gated implementation through explore-critique-integrate cycles to ensure semantic preservation.

What is the best way to plan a feature migration across different project architectures?

The best way to plan feature migration is generating a structured feature inventory from the source, running adversarial critique to identify gaps against the target architecture, and producing a gated porting plan before implementation.

Can I use this approach to migrate capabilities across separate repositories?

Yes, this approach specifically supports migrating capabilities across separate repositories by applying exhaustive feature extraction and gated implementation to preserve semantics across different project architectures.

Why does my code porting plan fail to preserve the original performance?

Code porting fails to preserve performance when lacking exhaustive extraction and adversarial critique. Applying gated, phase-based implementation with per-task critique and integration checks validates capabilities before finalizing the port.

Do I need subagents to execute a porting plan across codebases?

You do not need subagents to execute a porting plan unless explicitly requested. The process uses standard gated implementation directly, only spawning subagents for delegated or parallel work when higher-priority instructions allow it.

When do I need an adversarial critique loop for code porting?

You need an adversarial critique loop for code porting when migrating subsystems across projects. It identifies gaps against the target codebase and validates the porting plan before gated implementation begins.