Run any Skill in Manus with one click

legacy-rebuild

Stars0

Forks0

UpdatedJuly 5, 2026 at 07:42

[Tier 3 · high blast radius · expect rework · run deliberately, review the floor + architecture] Adversarially review a legacy app, research the best current architecture, and rebuild it end to end on a modern foundation while PRESERVING everything it currently does. Use when an app uses outdated everything (old deps, poor architecture, e.g. JS-inlined-in-HTML, no build/module system) and needs a real modernization, not a patch. Incremental and shippable per PR — NOT a big-bang rewrite — rebuilt against a captured behaviour floor so nothing is silently lost. Runs via the autonomous-fleet-core engine. Trigger on: "rebuild this legacy app", "modernize the whole codebase", "this uses all old versions, rebuild it properly", "re-architect end to end".

Installation

Install with Codex or Claude Copy this prompt, paste it into Codex, Claude, or another assistant, and let it review the skill page and install it for you.

Run Skill in Manus

Source

ravidsrk

ravidsrk/autonomous-fleet

View GitHub Repository View Creator Repositories

Download

Run Skill in Manus

Related occupationsSOC

Based on SOC occupation classification

Software DevelopersComputer and Mathematical Occupations·SOC 15-1252

File Explorer

4 files

SKILL.md

readonly

More from this repository

same repository

autonomous-fleet-core

ravidsrk/autonomous-fleet

The portable, tool-agnostic ENGINE for running fully-autonomous multi-agent engineering jobs. Shipped mission skills (doc-sync, test-coverage, adversarial-review-and-fix) invoke THIS engine plus exactly one ADAPTER (orca, claude-code, grok, or another runtime). Eighteen additional missions are documented under docs/exploratory/missions/ and re-promote on real-run evidence. This core holds everything that does NOT depend on orchestration tool: self-orientation, fully-autonomous coordinator behaviour with file-ledger boolean gates, context-handoff to survive compaction, the worker-placement DECISION LOGIC (dependent vs independent), the PR-per-task pipeline with commits-preserved + conflict-aware merge + worktree cleanup, the empirical risk tiers, safety rails, secret hygiene, and commit/authorship policy. It speaks in PRIMITIVES; the ACTIVE ADAPTER maps each primitive to its tool's real commands. Load with a mission skill and one runtime adapter — do not run alone.

2026-07-080

devex-audit

ravidsrk/autonomous-fleet

[Tier 2 · moderate autonomy · full review gate · developer-experience] Run a live developer experience audit with frozen DX scorecard and ranked documentation gaps. Maps gstack /devex-review and /plan-devex-review into fleet ledgers with optional document-generate follow-ups. Use when onboarding friction, CLI help, or docs TTHW need evidence before ship. Trigger on: "DX audit", "developer experience review", "devex mission", "audit onboarding", "score the getting started flow", "plan devex review".

2026-07-050

landing-page-convergence

ravidsrk/autonomous-fleet

[Tier 2 · moderate autonomy · full review gate] Force a production landing page that has DIVERGED from an approved design into full fidelity with that design - section by section, with a named divergence checklist as the forcing function so it converges instead of drifting. Use when a live page no longer matches its design export and needs to be brought back into line (a single page/site, not a whole app - that's design-integration). Extracts the design system, diffs production against it, and closes each divergence as its own PR. Runs via the autonomous-fleet-core engine. Trigger on: "make the landing page match the design", "the production page diverged from the design", "bring the landing page into parity", "fix the landing page to match the mockup".

2026-07-050

product-framing

ravidsrk/autonomous-fleet

[Tier 2 · moderate autonomy · full review gate · pre-build] Turn vague product intent into a frozen, review-approved product spec before any implementation. Runs gstack-style office-hours forcing questions plus CEO/design/eng plan reviews (via optional community skills), then emits docs/product-spec.md as the single source of truth for downstream build missions. Use when the user has an idea, wedge, or feature direction but no frozen spec yet. Trigger on: "frame this product", "office hours on this idea", "is this worth building", "freeze the product spec", "run plan reviews before we code", "product framing mission".

2026-07-050

release-document

ravidsrk/autonomous-fleet

[Tier 2 · moderate autonomy · full review gate · post-ship docs] Post-ship documentation sweep and deploy verification checklist after a version lands. Maps gstack /document-release, /ship, /land-and-deploy, and /canary into fleet frozen artifacts. Use after merge or deploy when changelog, user docs, and canary notes need closure. Trigger on: "document this release", "post-ship docs", "release documentation mission", "update docs after ship", "canary doc sweep".

2026-07-050

security-cso-audit

ravidsrk/autonomous-fleet

[Tier 2 · moderate autonomy · full review gate · security-specialist] Run a gstack-style CSO security audit (secrets archaeology, supply chain, CI/CD, OWASP, STRIDE, LLM/skill supply chain) with daily or comprehensive modes, freeze findings, then remediate confirmed issues one PR at a time with skeptic narrowing. Distinct from general adversarial-review-and-fix by infrastructure- first CSO lenses. Trigger on: "CSO audit", "security audit mission", "OWASP review", "threat model this repo", "run /cso as a fleet mission", "supply chain security pass".

2026-07-050

name	legacy-rebuild
description	[Tier 3 · high blast radius · expect rework · run deliberately, review the floor + architecture] Adversarially review a legacy app, research the best current architecture, and rebuild it end to end on a modern foundation while PRESERVING everything it currently does. Use when an app uses outdated everything (old deps, poor architecture, e.g. JS-inlined-in-HTML, no build/module system) and needs a real modernization, not a patch. Incremental and shippable per PR — NOT a big-bang rewrite — rebuilt against a captured behaviour floor so nothing is silently lost. Runs via the autonomous-fleet-core engine. Trigger on: "rebuild this legacy app", "modernize the whole codebase", "this uses all old versions, rebuild it properly", "re-architect end to end".
license	MIT
compatibility	Requires git and gh CLI in the target repository
metadata	{"author":"ravidsrk","version":"1.0.0","tier":"3","fleet-component":"mission"}
status	exploratory

Status: exploratory. This mission is documented but has not yet been run end-to-end on an external repo with an archived run-archive. It is preserved for future promotion (see docs/exploratory/missions/README.md § Promotion criteria). Do not invoke this skill in a production fleet until it has been promoted.

Mission: legacy-rebuild

Required skills

Before executing, activate these skills and read their full instructions:

autonomous-fleet-core — read references/engine.md and references/composition.md when coordinating
One runtime adapter: autonomous-fleet-adapter-orca, autonomous-fleet-adapter-claude-code, autonomous-fleet-adapter-grok, or autonomous-fleet-adapter-codex

Follow the core and your adapter in full, then apply the mission parameters below.

Do not load a second mission skill in the same run. For chained missions, use fleet-program.

Optional skills

Skill	Activate when	If unavailable
—	—	Run `test-coverage` as prior program step if floor is undertested

Worker skills

Role	Skills	If unavailable
@codex (rebuild units)	`frontend-design` if UI; else stack skill from manifests	Legacy floor + target architecture docs

Deferred missions

Record in final readiness doc under Recommended next missions and in DECISIONS.md.

Finding type	Route to
Light tidy sufficient (no rebuild)	`cleanup`
Product incomplete after modern stack	`take-product-to-completion`
Post-rebuild doc drift	`doc-sync`

Empirical note: highest-risk alongside take-product-to-completion. A from-scratch rebuild that must also preserve undocumented behaviour is where rewrites die — you discover behaviour only after deleting it. The two control artifacts are the LEGACY FLOOR (everything the app does today) and the TARGET ARCHITECTURE — review both. The floor is the contract that "rebuild" doesn't mean "lose things."

CORE PRINCIPLE

Do the adversarial review and capture the behaviour floor FIRST, pick a modern target architecture, then rebuild against the floor — incrementally shippable, not big-bang. The review and floor are what stop the rebuild from dropping features.

GOAL

A clean, modern, well-architected app on current tooling, with ZERO feature regressions vs. what exists today. Eliminate every anti-pattern the review flags (e.g. inlined JS, missing build/module system, dead code); adopt a current best-practice stack; preserve all existing behaviour, data, and external contracts. Each rebuilt unit lands working and tested.

ROLE PIPELINE

Builder choice (Stage-9 final form). Per prompts.md L3013 (Aula run, Stage-9 prompt 24), @grok is retired for general-purpose builds. Flipping to @codex.

@claude AUDITS + captures the FLOOR + RESEARCHES + freezes the architecture + per-unit specs.
@codex CODES each unit on the modern architecture.
A fresh build-blind @claude REVIEWS each PR: conforms to target architecture, preserves the unit's floor behaviour, real green tests, no legacy anti-pattern reintroduced.
@claude SHIPS: opens PR, conflict-aware merge, worktree cleanup.

LEDGER

<LEDGER_DIR>/rebuild-progress.md. Per-task flags: PLANNED=<t/f> BUILT=<t/f> REVIEWED=<t/f> SHIPPED=<t/f>. Plus a UNIT INDEX (each rebuild unit + the floor slice it preserves, OPEN | DONE via PR#n).

TASK STRUCTURE

T-AUDIT [@claude] — hostile audit: every anti-pattern, outdated dep/version, architectural smell (inlined JS, missing build/module system, dead code, duplication, no separation of concerns). Explain WHY the code is shaped this way and exactly what's wrong. Output docs/audit.md. (Parallel with FLOOR + RESEARCH.)
T-FLOOR [@claude, parallel] — control artifact. Capture EVERYTHING the app does today — every screen, route, feature, flow, state, behaviour (including undocumented behaviour found by exercising the app) — as the preservation floor. Output docs/legacy-floor.md.
T-RESEARCH [@claude, parallel] — research current best-practice architecture + tooling for this kind of app (framework, build/bundler, module approach, language/runtime versions, test stack, the modern patterns that replace the flagged anti-patterns). Fetch live sources; recommend a concrete stack with rationale. Output docs/research.md.
T-ARCH [@claude, Opus-class, gated on AUDIT+FLOOR+RESEARCH] — control point. Define the target architecture (chosen stack, structure, how each anti-pattern resolves). Decompose the rebuild into shippable units, each conforming to the architecture and preserving its floor slice. Per-unit specs + acceptance (architecture conformance + feature parity + tests), a dependency graph, and a PARALLELIZATION + FILE-OWNERSHIP map (independent → parallel; same-file → serialized), with shared FOUNDATION (build setup, structure, base tooling) called out first. Output docs/architecture.md + docs/rebuild-plan.md. FROZEN. Write each unit to the UNIT INDEX.
T-FOUNDATION [relay] — establish the new architecture's foundation (modern build/bundler, project structure, dependency upgrades to current versions, base tooling + test harness). Gates dependent units.
T-UNITS… [per unit, loop] — @codex rebuilds the unit on the modern architecture preserving its floor behaviour (tests) → fresh build-blind @claude reviews (architecture conformance + feature parity + real green tests) → @claude ships. Independent units parallel; file-overlapping/dependent serialized.
T-FINAL [@claude] — build green (on the NEW build system), lint clean, full suite green. The app is fully on the target architecture (no flagged anti-patterns remain); EVERY behaviour in docs/legacy-floor.md still works (zero regressions); no dead code/placeholders/console errors; all worktrees cleaned. Output <LEDGER_DIR>/rebuild-readiness.md with fleet-outcome YAML (units_open, floor_preserved), architecture-conformance summary, legacy-floor parity matrix complete, stack adopted, residual risks, all PRs). Ship as the final PR.

Runtime goal

After ledger init, SET_GOAL per autonomous-fleet-core/references/runtime-goals.md. Record ## Runtime goal in <LEDGER_DIR>/rebuild-progress.md. GOAL_COMPLETE only after ## DONE below.

Mission legacy-rebuild DONE: <LEDGER_DIR>/rebuild-progress.md all task flags true,
<LEDGER_DIR>/rebuild-readiness.md with fleet-outcome.status done and mission metrics satisfied,
./scripts/validate-fleet-outcome.sh passes, all PRs merged into BASE.

DONE

Every UNIT-INDEX item DONE, app fully on the target architecture, every legacy-floor behaviour preserved, every task terminal, suite green, <LEDGER_DIR>/rebuild-readiness.md exists. Then send the FINAL report.

DECISION DEFAULTS (mission-specific)

Modern architecture is the TARGET; the legacy floor (docs/legacy-floor.md) is what must NOT regress. Eliminate every anti-pattern the audit flagged.
Incremental + shippable per PR; never a big-bang replace. Each unit lands working and tested.
Preserve all existing behaviour, data, and external contracts; modernize the implementation, not the product's behaviour, unless the plan explicitly improves a flow.
Maximize parallelism: independent units concurrent in isolated worktrees; serialize file-overlapping units to minimize merge conflicts. Foundation first.
Tests real and behaviour-exercising; reject coverage-padding. Bar = every feature/flow tested and green, coverage not regressed.
Any ambiguity → the cleanest modern architecture with full feature parity while converging.