stack-select
/stack-select
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.
- Author
- devpilotX ↗
- Repository
- ai-skill-ai ↗
- Licence
- MIT
- Last repository change
- 31.10.2026
Assessment and security
- Files in this package
- 3
- Scripts
- 1
- HTML comments
- 0
- URLs in SKILL.md
- 0
No signals detected. Repository changed on 31.10.2026, without references to retired models or APIs.
MIT, open: use and modify while retaining author attribution.
- 1 scripts in this package. Review them before installing, as Claude may execute them.
Scripts: scripts/eol_check.py
What it does and when to use it
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.
Original author 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.
How it works
- When to use and when to stay off
- Non-negotiables
- Procedure
- Self-audit
- What this cannot do
SKILL.md preview
--- 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?"
Files in this package (3)
- SKILL.md 10 KB
- references/stack-sheet.md 9 KB
- scripts/eol_check.py 15 KB
Versions
The database has no other skills named stack-select.
Database snapshot: 13.11.2026 · package version 3393e1ad2b39 (SHA-256 digest of the entire package)
Downloads in the last 30 days: 0 · ranking
Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.
Similar skills
- 100stack-selection
Use in the architecture phase, or whenever someone asks "what should we build this with?", "which framework/language/database/hosting?", or wants to compare stacks. Asks for the project's constraints first, compares two or three genuinely different candidate stacks in a decision… - 100stack-architect
Choose the exact right tech stack before building any software — frontend, backend, database, cache, ORM, auth, hosting, deployment, CI/CD, backups, monitoring, security, email, payments, storage and every supporting service. Use this skill whenever the user is starting a new… - 100upgrade-runtime-stack
Check whether newer stable versions of Node.js (24.x line), Nx, or Vite are available and, if so, generate a detailed upgrade plan markdown file at the repo root. Use this skill whenever the user asks to "check for runtime upgrades", "upgrade Node/NX/Vite", "is our Node version… - 100tech-stack
☕️ cafe · The canonical, opinionated technology stack for any new project — what to reach for, in what order, and what to never touch. Use this whenever a new project starts or a stack decision comes up: scaffolding an app, prototype, dashboard, landing page, or design system,… - 100choose-stack
[Orbit 2.2.4 Architecture & data] Choose/confirm the stack: existing stack by default, ecosystem, platform, pinned versions. Use when: «какой стек», «выбери фреймворк», «версии», «на чём писать»; tech stack, pick a framework, pin versions. - 90dev-migrate
Plan and run a move of part or all of a project to another language, framework, database or platform, step by step with behaviour kept the same and proven by tests. Use for "/raystack project migrate", "migrate this service to Rust", "move from Express to Go", "port this to…