One-click install
npx skills add https://github.com/reliant-labs/forge --skill migration-reliant-labs
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: migration
Source: https://github.com/reliant-labs/forge/tree/main/internal/templates/project/skills/forge/migration
Command: npx skills add https://github.com/reliant-labs/forge --skill migration-reliant-labs

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill prevents broken or subtly incorrect scaffolds when porting an existing Go codebase into a Forge-generated project structure, by guiding the required pre-flight checks and a safe porting order. It also reduces time wasted on environment/tooling mismatches and common migration footguns that only surface after codegen or runtime failures.

Core Features & Use Cases

  • Pre-flight readiness checks: verifies tool availability and environment visibility so Forge subprocess codegen behaves deterministically.
  • Project-shape and module-path strategy: helps you choose the correct service, cli, or library scaffold shape and plan a safe -next cutover module strategy.
  • Deterministic porting and verification loop: recommends an incremental migration order with repeated forge generate, go mod tidy, go build, and forge lint, including an early contracts floor and per-phase contract linting.

Quick Start

Follow the migration pre-flight checklist, scaffold a <name>-next project with the correct --kind and --mod, then port internal packages first while running forge generate and lint after each component addition until you reach a clean build baseline.

Frequently Asked Questions about migration

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

FAQPage Schema
How do I migrate an existing Go project into a Forge scaffold without breaking the build?

To migrate a Go project into a Forge scaffold safely, scaffold a `<name>-next` project with the correct `--kind` and `--mod`, then port internal packages first while running `forge generate` and `forge lint` after each component addition until you reach a clean build baseline.

What pre-flight checks are needed before porting a Go codebase to a Forge-generated project structure?

Pre-flight checks for Forge project porting verify tool availability and environment PATH visibility so Forge subprocess codegen behaves deterministically, alongside setting up an early contracts policy floor in your `forge.yaml` configuration.

How do I choose the correct scaffold shape and module-path strategy for a Go project migration?

Choosing the correct scaffold shape requires selecting `service`, `cli`, or `library` based on your project type, and planning a safe `-next` cutover module strategy to handle the Go module path transition without breaking existing imports.

What is the safest install order for porting internal packages, handlers, and wiring during a Forge migration?

The safest pack and component install order for Forge migration is incremental: port internal packages first, followed by handlers and dependency wiring, while repeatedly running `forge generate`, `go mod tidy`, `go build`, and `forge lint` after each phase.

Why does Forge codegen or runtime behavior fail when porting an existing Go codebase into a new scaffold?

Forge codegen and runtime behavior fail during Go codebase porting due to environment and tooling mismatches, incorrect module-path strategies, or bypassing the required pre-flight checks and deterministic per-phase contract linting verification gates.

Can I use Forge to port a Go project if my internal contracts are not yet defined in forge.yaml?

You cannot safely port a Go project using Forge without an early contracts floor defined in `forge.yaml`, as per-phase contract linting is required to prevent subtle scaffold inaccuracies and verify the build baseline after each component addition.