phoenix
/phoenix
Przebudowuje istniejącą aplikację w wersję drugą etapami: mapuje ją, planuje architekturę, buduje, testuje i porównuje z oryginałem.
- Autor
- komilovsg ↗
- Repozytorium
- phoenix ↗
- Licencja
- MIT
- Ostatnia zmiana repozytorium
- 11.11.2026
Ocena i bezpieczeństwo
- Pliki w paczce
- 8
- Skrypty
- 0
- Komentarze HTML
- 0
- Adresy URL w SKILL.md
- 0
Brak sygnałów. Repozytorium zmienione 11.11.2026, bez odwołań do wycofanych modeli i API.
MIT, otwarta: można używać i zmieniać, z zachowaniem informacji o autorze.
Co robi i kiedy
Przebudowuje istniejącą aplikację w wersję drugą etapami: mapuje ją, planuje architekturę, buduje, testuje i porównuje z oryginałem.
Wyzwalacze z opisu
Oryginalny opis (EN)
Rebuild any app into a better v2, phase by phase: map it (from its own code, routes, types, OpenAPI and git history of fixes, or from public surfaces for a third-party app), plan architecture and API contract, rebuild the design system, build, wire the backend, test, score parity vs the original, then add "wow" upgrades from real user pain, rebrand, launch, deploy. Use when the user wants to rebuild, clone, remake or rewrite an app from scratch, make a "v2", reverse-engineer a product, migrate a legacy frontend, run a parity check against the original, or asks what to add for "wow" / what user
Jak działa
- Step 0: pick the mode, scope, and target
- Phase router
- Tools (stdlib Python 3.8+, no installs)
- Hard rules
- Working rules
- Verification gates (a phase is done only when its gate passes)
- Summary format after each phase
Podgląd SKILL.md
---
name: phoenix
description: >-
Rebuild any app into a better v2, phase by phase: map it (from its own code,
routes, types, OpenAPI and git history of fixes, or from public surfaces for
a third-party app), plan architecture and API contract, rebuild the design
system, build, wire the backend, test, score parity vs the original, then add
"wow" upgrades from real user pain, rebrand, launch, deploy. Use when the user
wants to rebuild, clone, remake or rewrite an app from scratch, make a "v2",
reverse-engineer a product, migrate a legacy frontend, run a
parity check against the original, or asks what to add for "wow" / what users
hate about an app. Russian: "пересобрать приложение", "вторая версия", "v2",
"переписать с нуля", "клон приложения", "мигрировать старый фронт", "сравнить
с оригиналом", "что добавить для вау", "сделать лучше оригинала".
---
# phoenix
Rebuild any app. Reborn better.
Turns app v1 (yours or someone else's) into v2: same jobs done, fewer bugs,
better UX, plus upgrades users actually asked for. Every phase writes a file
into `rebuild/` in the **v2 project**, and every later phase reads those files.
Skipping a phase means the next one works from memory, which is how half an
app gets missed.
## Step 0: pick the mode, scope, and target
Ask, or propose and get a yes:
1. **Mode**
- **own** — the user owns v1 and its source is on disk (e.g.
`~/code/shop-web` → rebuild in `~/code/shop-v2`).
Recon reads code. Full reuse of code, copy, brand and assets is allowed.
- **third-party** — someone else's app. Recon reads public surfaces and the
user's own account only. Clean room: features and flows, never code,
brand, copy or assets.
2. **Slice**: the core loop first (the one flow users come for), then the rest.
3. **Target**: v2 repo path, stack constraints, who v2 is for.
v1 source is **read-only**. Never edit, build, install in, or commit to it.
## Phase router
Load only the reference for the phase you are in.
| # | phase | load | writes to `rebuild/` |
|---|---|---|---|
| 1 | recon (own code) | `references/recon-own-code.md` | `recon.md`, `features.csv`, `domain-map.md`, `bug-classes.md` |
| 1 | recon (third-party) | `references/recon-public.md` | `recon.md`, `features.csv`, `screens/` |
| 2 | upgrade research | `references/upgrade.md` (steps 1-4) | `reviews.csv`, `feedback.md`, `fixes.md` |
| 3 | architect + API contract | `references/architect.md` | `architecture.md`, `schema.sql`, `openapi.yaml` or `api.md` |
| 4 | design system | `references/design.md` + `references/ui-quality.md` | `design/tokens.json`, `tokens.css`, `components.md` |
| 5 | build | `references/build.md` (+ `ui-quality.md` per screen) | code, `build-log.md`, `clone-screens/` |
| 6 | backend | `references/backend.md` | migrations, `backend.md`, `.env.example` |
| 7 | test | `references/test.md` | `test-plan.md`, `bugs.md`, `e2e/` |
| 8 | parity diff | `references/diff.md` | `parity.md`, `diffs/` |
| 9 | wow upgrades (build them) | `references/upgrade.md` (step 5-6) | new `features.csv` rows, `fixes.md` status |
| 10 | brand | `references/brand.md` (required for third-party, optional for own) | `brand.md`, `brand.json` |
| 11 | launch | `references/launch.md` | `launch/` |
| 12 | deploy | `references/deploy.md` | `deploy.md` |
Order note: for a v2 run upgrade **research** (phase 2) right after recon, so
the architecture designs the fixes in instead of bolting them on. Building the
upgrades still waits until parity is reached (phase 9).
Templates live in `assets/templates/` (recon-map, features.csv, architecture,
tokens.json, test-plan, bug-report, e2e spec, listing, preflight). Copy, do
not edit in place.
## Tools (stdlib Python 3.8+, no installs)
Run from the v2 project root; `$T` = the skill folder (`~/.claude/skills/phoenix`, or the plugin install path).
```bash
python3 $T/scripts/parity.py rebuild/features.csv [--visual rebuild/diffs/*.json] [--markdown] [--fail-under 80]
python3 $T/scripts/imgdiff.py v1.png v2.png [--out diff.png] [--json] [--mode pixel]
python3 $T/scripts/contrast.py rebuild/design/tokens.json # WCAG AA, exit 1 on failure
python3 $T/scripts/reviews.py rebuild/reviews.csv --out rebuild/feedback.md [--themes my.json]
python3 $T/scripts/sweep.py . --config rebuild/brand.json # leftovers of the original, exit 1 on hit
python3 $T/scripts/listing.py rebuild/launch/listing.json # store listing limits + avoid list
```
Run them with `python3 -I` when the input files came from outside.
## Hard rules
**Clean room (third-party mode).** Rebuild what the app does, never what it
owns: no source, bundles, private APIs, network-log endpoints, logos, icons,
illustrations, licensed fonts, copy, or brand colour. Public pages and the
user's own account only, read at human speed, no scraping, no paywall or login
tricks. If the user's account terms forbid building a competitor, say so and
use public sources only. Screenshots are reference and never ship. Nothing
launches until the brand sweep is clean.
**Own mode.** Reuse anything from v1: code, i18n messages, assets, brand. But
port deliberately: a file from a bug hotspot (see `bug-classes.md`) is
rewritten, not copied.
**Honesty.** Never fabricate reviews, quotes, metrics, counts, test results or
check results. A check nobody ran is "to run". A parity of 62% is 62%.
**User does accounts and money.** Claude never signs up, buys, types passwords,
cards or live keys. It writes `.env.example` (names only), DNS records and
exact commands; the user executes account steps.
## Working rules
The user's own instructions (CLAUDE.md, AGENTS.md, repo conventions) win over
everything below. Defaults when they say nothing:
- **Split the work.** The main session plans, writes specs and reviews.
Implementation goes to subagents from precise specs: files, rules, owner
decisions, acceptance tests, what not to touch. Architecture, API contract,
security, authorisation, data isolation and money stay with the strongest
model. Every subagent result is verified before it counts.
- **Tests where it runs.** A fullstack v2 with its own backend runs its suite
in a Linux container before every push (macOS hides file-name case bugs) and
keeps a case-sensitivity guard test. Frontend-only: host tests are enough.
- **Commits.** Follow the repo's style. Commit and push only when asked. Never
merge into a base branch or open/merge PRs unless the user says so.
- **Keep the stack.** Keep the animation, state and UI libraries v1 already
uses unless the architecture phase records a reason to change.
- **Token economy.** Aggregate before reading (counts, `uniq -c`, jq picks),
keep exit codes, use quiet test reporters, never print secrets or real PII.
## Verification gates (a phase is done only when its gate passes)
| phase | gate |
|---|---|
| recon | every screen has an ID, route and states; every flow has a click count; every feature row has evidence (file path in own mode, URL in third-party); `bug-classes.md` has counts from real git commands (own) |
| upgrade research | every quote verbatim and linked; sample size stated; thin themes marked thin |
| architect | every entity has owner column + access rule; every flow has routes; every bug class has a design-out decision; contract is machine-readable if v1 had OpenAPI |
| design | `contrast.py` exit 0; primitives built in isolation and screenshotted; no raw hex/px in components |
| build | per-screen definition of done (`build.md`); `features.csv` updated; screenshot saved |
| backend | second-user isolation test passes; webhooks idempotent; security checklist ticked |
| test | suite green (Linux docker if fullstack); no open S1; bugs only reproduced ones |
| diff | `parity.py` run; all must-haves done; verdict written with honest numbers |
| upgrades | each upgrade traces to evidence (review link or bug class) and has a test |
| brand | `sweep.py` exit 0 (third-party); checks marked run/to-run with dates |
| launch | `listing.py` exit 0 if stores; no fake proof |
| deploy | preflight all green, the user's explicit go, live core flow done on desktop and phone |
Every subagent result is checked by a verifier, tests or CI before it counts.
## Summary format after each phase
Five lines max: what was written (paths), the key numbers (screens, flows,
must-haves, parity, bugs by severity), the top risks, what is blocked on the
user, and the next phase.
Pliki w paczce (8)
- .gitignore 1 KB
- ARCHITECTURE.md 4 KB
- CHANGELOG.md 1 KB
- LICENSE 1 KB
- README.md 6 KB
- SECURITY.md 3 KB
- SKILL.md 8 KB
- THIRD_PARTY_NOTICES.md 4 KB
Wersje
| Repozytorium | Wynik | Licencja |
|---|---|---|
| Ta strona · komilovsg/phoenix | 100 | MIT |
| ericrisco/rsc-harness | 100 | MIT |
| vinnie357/claude-skills | 100 | MIT |
| G1Joshi/Agent-Skills | 100 | MIT |
| georgeguimaraes/claude-code-elixir | 100 | Apache-2.0 |
Migawka bazy z 13.11.2026 · wersja paczki ea3be1b1997a (skrót SHA-256 całej paczki)
Pobrania w ostatnich 30 dniach: 0 · ranking
Zgłoś problem z tym skillem: szkodliwa treść, błędny opis albo prośba autora o usunięcie.
Podobne skille
- 100reverse-engineer-and-rebuild
Odtwarza działającą stronę, aplikację lub API na podstawie adresu URL albo dostarczonego pliku i porównuje oryginał z kopią. - 100replica-diff
Porównuje klon aplikacji z oryginałem: wynik zgodności funkcji z listą brakujących i zrzut różnic układu bez kolorów. - 100recreate-diff
Porównuje klon aplikacji z oryginałem: wynik zgodności funkcji z macierzy z wagami, listę braków i różnice układu ekranów bez kolorów. - 100replica-diff
Ocenia zgodność klonu z oryginałem przez listę funkcji i porównanie zrzutów ekranu, ignorując kolory, by zmiana marki nie obniżała wyniku. - 90reverse-engineer-app
Prowadzi początkującego przez badanie aplikacji, którą posiada, ma otwarty kod albo na którą ma zgodę, i pomaga zbudować własną wersję. - 95replica-diff
Porównuje klon aplikacji z oryginałem: wynik zgodności funkcji i różnice układu na zrzutach ekranu, bez oceny kolorów.