Przejdź do treści
Biblioteka skilli
Programowanie · Analiza

stack-select

/stack-select

Dobiera język, framework, runtime i bazę dla każdego elementu według sprawdzonych bieżących wersji i okien wsparcia.

Repozytorium
ai-skill-ai ↗
Licencja
MIT
Ostatnia zmiana repozytorium
31.10.2026

Ocena i bezpieczeństwo

100/ 100Klasa: dobry
Format25 / 25
Frontmatter z nazwą i opisem, poprawna nazwa, opis do 1024 znaków, nazwa zgodna z folderem.
Odkrywalność25 / 25
Opis mówi, kiedy użyć skilla, ma sensowną długość i jest w 3. osobie.
Treść35 / 35
Co najmniej 150 słów i do 500 linii, nagłówki, listy kroków, przykłady albo kod.
Higiena15 / 15
Bez zaślepek typu TODO, bez ścieżek Windows, z licencją.
Ryzykobrak sygnałów w skanie
Pliki w paczce
3
Skrypty
1
Komentarze HTML
0
Adresy URL w SKILL.md
0
Przestarzałość

Brak sygnałów. Repozytorium zmienione 31.10.2026, bez odwołań do wycofanych modeli i API.

Licencja

MIT, otwarta: można używać i zmieniać, z zachowaniem informacji o autorze.

Co sprawdzić przed instalacją
  • 1 skrypt w paczce. Przejrzyj je przed instalacją, bo Claude może je uruchomić.

Skrypty: scripts/eol_check.py

Co robi i kiedy

Dobiera język, framework, runtime i bazę dla każdego elementu według sprawdzonych bieżących wersji i okien wsparcia.

Oryginalny opis (EN)

Choose the language, framework, runtime and datastore per component from verified current versions and support windows, not from habit. Use when someone asks what stack should I use, which framework, what language, Node or Go or Rust, React or not, which database, Redis or Valkey, or is this version still supported; and before build-pilot commits a stack. Scores options against team skill, hiring market, ecosystem, measured performance need, hosting cost and longevity, gives defaults with reasons, and verifies every version and end-of-life date live with scripts/eol_check.py against endoflife.

Jak działa

  1. When to use and when to stay off
  2. Non-negotiables
  3. Procedure
  4. Self-audit
  5. What this cannot do
Sekcje z nagłówków SKILL.md, w oryginale · 138 linii, 1 476 słów
Podgląd SKILL.md
---
name: stack-select
description: Choose the language, framework, runtime and datastore per component from verified current versions and support windows, not from habit. Use when someone asks what stack should I use, which framework, what language, Node or Go or Rust, React or not, which database, Redis or Valkey, or is this version still supported; and before build-pilot commits a stack. Scores options against team skill, hiring market, ecosystem, measured performance need, hosting cost and longevity, gives defaults with reasons, and verifies every version and end-of-life date live with scripts/eol_check.py against endoflife.date before recommending. Produces a stack sheet per component. Triggers on what stack, which framework, what language should I use, Node vs Go, which database, is my Node version still supported. For a hard-to-reverse choice needing a decision record use arch-decide. For running the build use build-pilot. For vetting one library or API use oss-sourcing. For the per-change CI and version-pinning loop use quality-gates.
license: MIT
metadata:
  version: 1.0.2
  suite: ai-skill
---

# Stack selection

Most stack choices are made by habit: the last project's stack, the framework in the tutorial someone
watched, the language a team already likes. That is cheap when it happens to fit and expensive when it
does not, because a stack decides hiring, hosting cost and the next three years of maintenance, and
unwinding it later is a migration. This skill makes the choice deliberate and grounds it in versions
and support dates checked this session, so the recommendation does not rest on a number that was true
a year ago.

## When to use and when to stay off

Run when the question is which language, framework, runtime or datastore to use for a component, when
someone asks whether a version is still supported, or just before a build commits to a stack.

Stay off, and route instead, when:

- The choice is a single hard-to-reverse decision that needs a written decision record with options and a reversal trigger. `arch-decide` owns that. This skill feeds it the versions and the shortlist; `arch-decide` records the decision.
- The request is to run the whole build, not just pick the stack. `build-pilot` owns the staged build and calls this skill at its research and decide stages.
- The task is finding and vetting one specific library, API or dataset (licence, rate limits, supply-chain health). `oss-sourcing` owns that.
- The work is the per-change verification loop, the CI workflow, and pinning versions in a lockfile and in CI. `quality-gates` owns that.
- The component is already chosen and the work is building it. Route to `backend-build`, `frontend-build`, `data-layer`, `mobile-build`, `ml-build` or `infra-deploy`.
- The question is the local development environment and tooling for a stack already chosen. `devex-tooling` owns that.

The user says "stop", "I've decided", or "just execute": comply at once and stay off for the rest of
the session unless asked again. Record the decision so the build that follows can use it.

## Non-negotiables

These override everything else in this file.

1. No version, support date or licence claim unless it was verified this session against a primary source (endoflife.date, the project's release notes, the licence file) or labelled `ASSUMPTION:` with its risk. Recall is not verification; these dates move.
2. Run `scripts/eol_check.py` against the project's manifests, or fetch the endoflife.date data for each runtime named, before recommending a version. Paste what it printed.
3. Never recommend a version that is already past end of life as a new default. If the project is pinned to one, name it and the upgrade it implies.
4. Score at least two options against the decision criteria for any choice that is not trivial. A recommendation with no alternative considered is a preference, not a selection.
5. The decision criteria are weighed in order: team skill and maintenance first, then hiring market, ecosystem, measured performance need, hosting cost, longevity. Do not lead with raw performance for an I/O-bound workload.
6. A one-way-door choice (a datastore holding the system of record, a language the whole team must learn, a framework that shapes the architecture) is handed to `arch-decide` for a decision record. This skill does not record the decision itself.
7. Record the licence of any datastore or runtime whose licence is not plain permissive, in particular Redis against Valkey. State which licence of a multi-licence project you are relying on.

## Procedure

The stack sheet template, the ordered decision criteria, defaults with reasons, and a dated table of
support windows for Node.js, Python, Go, Rust, Next.js, React and PostgreSQL, plus the Redis and
Valkey licence status, are in `references/stack-sheet.md`. Read it before recommending.

### Step 1, split the system into components

A system rarely has one stack. Name each component that could reasonably take a different choice: the
web front end, the API or backend, background workers, the data or machine-learning pipeline, the
datastore, the cache. Choose per component, because the right language for a data pipeline is usually
not the right one for a web front end.

For each component write down the workload shape in one line: is it I/O bound (waiting on network,
disk or a database) or CPU bound (doing heavy computation)? This decides whether a faster language
would move the number that matters. Most web and API workloads are I/O bound.

### Step 2, gather the constraints

Ask only what changes the choice: who maintains this and what do they already know; how long must it
be staffed; what has to integrate with it; is there a hosting constraint (a platform already in use, a
cost ceiling, serverless versus servers); and is any part of it genuinely performance-critical with a
number attached, or is that an assumption.

If there is an existing codebase, read what it already uses before proposing anything. Changing stack
mid-project is a migration (`migration-plan`), not a selection, and the bar for it is high.

### Step 3, verify versions and support windows live

Run the checker against the project:

```
python3 scripts/eol_check.py --path . --warn-days 180
```

It reads `package.json`, `pyproject.toml`, `requirements*.txt`, `Cargo.toml`, `go.mod`, `.nvmrc`,
`.python-version` and `Dockerfile*`, detects the version pinned for each known runtime or framework,
and queries endoflife.date for whether each is supported, near end of life, or past it. Use `--json`
for a machine-readable report and `--strict` to fail on a near-end-of-life version as well. With
`--offline`, or when the network is unavailable, it detects versions but marks every status
`unknown` and says so rather than guessing.

For a greenfield project with no manifests yet, fetch the endoflife.date data for each runtime you are
considering and record the current stable, the active LTS where one exists, and the end-of-life date,
with the date you checked. The table in `references/stack-sheet.md` is a starting snapshot; confirm it
is still current.

### Step 4, shortlist and score

For each component, list the realistic options, including the obvious default and at least one that is
not it, and "adopt something that already exists" where that applies. Score each against the criteria
in the order fixed by non-negotiable 5. For each option name what it optimises for, what it costs, who
has to learn something, and its failure mode.

Use the defaults in `references/stack-sheet.md` as starting points, not answers. A default that does
not fit the constraints from step 2 loses to one that does.

### Step 5, decide or hand off

For a reversible, component-local choice, record it in a stack sheet from `references/stack-sheet.md`:
the chosen stack, the pinned version with its support date and source, why it beat the alternative,
the hosting and cost shape, and any open risk labelled `ASSUMPTION:`.

For a one-way-door choice, hand the shortlist and the verified versions to `arch-decide`, which writes
the decision record with a reversal trigger. Say plainly which choices you treated as one-way doors
and why.

Where money is part of the comparison (hosting cost at scale, managed versus self-run), use
`business-model` for the cost side rather than guessing.

## Self-audit

- Every version, support date and licence claim has a primary source and the date it was checked, or an `ASSUMPTION:` label with its risk.
- `scripts/eol_check.py` was run (or endoflife.date fetched for a greenfield project) and its output is pasted.
- No recommended default is past its end-of-life date; any end-of-life version the project is pinned to is named with the upgrade it implies.
- Each non-trivial choice scored at least two options, one of them not the obvious default.
- The criteria were weighed in the fixed order, and performance did not lead for an I/O-bound workload.
- One-way-door choices were handed to `arch-decide`, not recorded here.
- The datastore and cache licence is recorded, with the specific licence relied on where a project is multi-licensed (Redis).
- A stack sheet exists for each component, with the pinned version and its support date.

## What this cannot do

It cannot verify versions, support dates or licences without a way to fetch them. With no network,
`eol_check.py` reports `unknown` and every external fact stays an `ASSUMPTION:`, and the report must
say so.

It cannot measure a performance claim for you. "This needs Rust for speed" is an assumption until a
profile or a benchmark on a representative workload shows CPU is the bottleneck. Without that evidence,
treat the I/O-bound default.

It does not write the decision record for a one-way-door choice; that is `arch-decide`.

It cannot decide a licence obligation. When a choice turns on whether a source-available or AGPL
licence (for example Redis under SSPLv1 or AGPLv3) permits your intended use, or whether your
deployment counts as offering a managed service, ask a software licensing lawyer: "Given that we
deploy and expose this component in this way in these countries, does its licence permit this use, and
does it place any obligation on us to publish our modifications or to hold a commercial agreement?"
Pliki w paczce (3)
  • SKILL.md 10 KB
  • references/stack-sheet.md 9 KB
  • scripts/eol_check.py 15 KB

Wersje

W bazie nie ma innych skilli o nazwie stack-select.

Migawka bazy z 13.11.2026 · wersja paczki 3393e1ad2b39 (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

  • 100stack-selection
    Porównuje dwa lub trzy różne stosy w tabeli decyzji, sprawdza wersje w dokumentacji i zapisuje wybór jako ADR.
  • 100stack-architect
    Dobiera stos technologiczny przed budową: frontend, backend, bazę, hosting, CI/CD, monitoring i usługi pomocnicze.
  • 100upgrade-runtime-stack
    Sprawdza, czy są nowsze stabilne wersje Node.js 24, Nx lub Vite, i przygotowuje plan aktualizacji w pliku markdown.
  • 100tech-stack
    Podaje sprawdzony domyślny stos technologiczny dla nowego projektu: framework, bibliotekę UI, bazę, ORM, uwierzytelnianie i hosting.
  • 100choose-stack
    Wybiera lub potwierdza stos technologiczny: istniejący stos domyślnie, ekosystem, platformę i przypięte wersje.
  • 90dev-migrate
    Planuje i prowadzi przeniesienie projektu na inny język, framework, bazę lub platformę, krok po kroku, z testami potwierdzającymi zachowanie.

Uwagi i zgłoszenia

Wiadomość trafi do Bartosza Sokolińskiego. Adres e-mail jest potrzebny tylko do odpowiedzi. Szczegóły w polityce prywatności.