decisium
/decisium
Projektuje, pisze i naprawia scenariusze Gherkin Decisium, czyli kroki w języku naturalnym wykonywane przez Jeva, na podstawie kodu lub wymagań.
- Autor
- andletenkov ↗
- Repozytorium
- decisium ↗
- Licencja
- MIT
- Ostatnia zmiana repozytorium
- 13.11.2026
Ocena i bezpieczeństwo
- Pliki w paczce
- 4
- Skrypty
- 0
- Komentarze HTML
- 0
- Adresy URL w SKILL.md
- 0
Brak sygnałów. Repozytorium zmienione 13.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
Projektuje, pisze i naprawia scenariusze Gherkin Decisium, czyli kroki w języku naturalnym wykonywane przez Jeva, na podstawie kodu lub wymagań.
Oryginalny opis (EN)
Design, write or repair Decisium Gherkin features (natural-language Steps run by Jev). Use when generating test scenarios from app code or requirements, writing a .feature for Decisium, or when a Step ends AMBIGUOUS, UNVERIFIABLE or STEP_TIMEOUT.
Jak działa
- Design (when generating from app code or requirements)
- Write
- Run and repair
Podgląd SKILL.md
---
name: decisium
description: Design, write or repair Decisium Gherkin features (natural-language Steps run by Jev). Use when generating test scenarios from app code or requirements, writing a .feature for Decisium, or when a Step ends AMBIGUOUS, UNVERIFIABLE or STEP_TIMEOUT.
---
Decisium runs each Step by asking Jev, a decision model that only picks among offered answers; code decides pass/fail.
A Step's wording decides most outcomes. The wording rules, per kind of Step, are in
[references/steps.md](references/steps.md). Read it before writing a Step. This skill is the procedure.
## Design (when generating from app code or requirements)
Skip this when the user already gave the scenarios. App logic first, input fields last: a suite of form-validation
cases that never completes a real journey is a failed design.
1. Map critical user journeys (CUJs). From requirements and code (routes, handlers, domain services, models), list
the end-to-end goals users come for (sign up → first value, search → buy → order confirmed, create → share →
collaborator sees it). Rank by business impact × usage × how badly a break hurts (money, data loss, lock-out).
Note the source (`file:line` or requirement id) of each.
2. Cover each CUJ with app logic before inputs:
- **Happy path end to end**, checking the business outcome (order exists with the right total, item visible to
the other role), not just "a success message".
- **Business rules and variants** that change the outcome: roles and permissions, plan/limit tiers, pricing,
discounts, ownership. Use a **decision table** (one case per distinct outcome, not every combo).
- **State transitions** of the domain objects the journey moves (draft → published, cart → order → refunded):
each allowed transition, plus one disallowed one per state that the UI can attempt.
- **Journey breaks**: abandon and resume, reload/back mid-flow, duplicate submit, already-used values, session
expiry, permission denied.
3. Only then, input fields on the CUJ path: **equivalence classes** (one valid + one per distinct invalid class) and
**boundary values** (at, just below, just above each limit found in code, e.g. `min(8)` → 7, 8 chars). Skip fields
off the critical journeys unless asked.
4. Prioritise in that order: CUJ happy paths, business rules and states, journey breaks, then inputs. Drop cases
the UI cannot observe (pure backend, timing) and say so.
5. Decide automate or not, per case. Automate when the value (CUJ, risk, how often it runs) beats the cost:
- **Setup**: can the precondition be reached through the UI or a seeded account in a few Steps? Needing a
specific DB state, a past date, a paid plan, an admin action or a third party (payment, email/SMS code, OAuth,
captcha) is a cost; prefer a test account or sandbox that already holds it.
- **Cleanup / repeatability**: does the run leave data that breaks the next run (unique email taken, stock used,
item already published)? Use unique values per run or a self-cleaning flow; irreversible side effects (real
payment, real email to customers, deleting shared data) mean do not automate against that environment.
- **Determinism**: time, randomness, async jobs, rate limits, A/B flags → flaky unless controllable.
- **Observability**: the outcome must show in the UI; otherwise it is not a Decisium case.
Mark each case `automate`, `automate later (needs: …)` or `manual (why)`. Write only `automate` cases; list the
rest with what would unblock them. Tag Scenarios needing special setup (e.g. `@needs-seed-admin`).
6. Shape: one behaviour per Scenario, named by its expected outcome. Same flow with different data → a
`Scenario Outline` with `Examples` (one row per class/boundary). Each Scenario is independent (fresh browser), so
repeat setup Steps, use `Background` (one file), or a state (below) for setup shared across features. Every Scenario ends with a check of the observable outcome (message text,
value, page), never just an action. Use only data the app accepts or rejects deterministically.
7. Show the user the CUJ list and case list (journey, behaviour, technique, source, automate decision) before
writing, if long or requirements were ambiguous.
## Write
1. Write the feature: an `@url:<start url>` tag, then one Scenario per user journey, each starting from a fresh browser.
Word each Step like a **Write** row of its kind (navigate, type, select, act, attempt, keys, value / presence /
scoped / state check, memory, secrets). Quote every value the Step uses and every value a check compares.
Credentials go in as `"$NAME"` placeholders, with the variables set in the environment or `.env`.
**Shared setup (login, consent, a built cart) → a state**: a `@state-def:<name>` Scenario in a `*.state.feature`
file (with its `@url:`), used by a Scenario tagged `@state:<name>` (at most one, no own `@url:`; it continues on
the page the state ended on). Chain with `@state:<other>` on the definition. Add `@save:storage` when the result
lives only in cookies/`localStorage` (login): it runs once per run and is loaded into later scenarios; it must end
with a `Then` check. Not for page or `sessionStorage` state. A state is setup: its failure exits 2; keep real login
coverage in a normal feature. Never put `@state-def:`/`@state:` on a Feature or a `Background` in a state file.
2. Run `decisium lint <file.feature>`. It shows how each Step will be read (kind, quoted values, placeholders) and
flags wordings to avoid with ⚠. Done when every ⚠ is reworded away, or kept on purpose with a `#` comment saying why.
## Run and repair
3. Run `decisium run <file.feature>` (live Jev the first time; it records a cassette next to the feature).
4. On a failure, read `runs/<id>/report.md`: the Step at `file:line`, Jev's answers, the page text around the element,
and a rerun command for that scenario. Classify each failure:
- **The app is wrong** (ASSERTION_FAILED, BLOCKED with the expected control truly missing): keep the Step, and
report the app behaviour.
- **An action target is AMBIGUOUS and the report lists Resolutions**: compare the candidates' role, name,
container and disambiguating text/position with the screenshot and the intended action. When one is clearly
correct, follow **Pin a Resolution** below instead of rewording or calling Jev again. Probability alone is not
evidence that a candidate is correct.
- **The wording is unclear** (no clearly correct pinnable Resolution, UNVERIFIABLE, a check that picked the wrong
element): reword using [references/troubleshooting.md](references/troubleshooting.md), then rerun just that scenario.
- **`AMBIGUOUS: Jev chose … which is not "X"`** usually means the Step before already used X (it finished the task):
merge the two Steps, not an app bug.
- A **marginal pass** warning means the pass rested on a barely-confident answer. Treat it like an unclear wording.
5. Keep the test's intent fixed while rewording. The quoted expected values and the area a check looks in stay as
written. A rewording that makes a check pass by reading a different element (a link instead of the heading, a
search box instead of the article) is a false pass. Compare Jev's subject in `report.md` with what the scenario
means.
### Pin a Resolution
1. Copy the ready-to-run command printed under the correct Resolution in the console or `report.md`, e.g.
`decisium pin 'features/campaign.feature:12' 2`; its Step location and candidate number are already filled in.
Pin writes the chosen Resolution into the existing cassette without
a browser, an API key or rewording. Inspect the cassette diff: `pinned` retains the chosen candidate, turn and
original probabilities. Keep the pin only when it matches the scenario's intent.
2. Replay the scenario with `decisium run features/campaign.feature:<scenario-line> --record none`, using the
report's scenario location and any original URL/configuration options. Replay needs no `TYPESAFE_API_KEY`;
the selected Resolution must still match exactly one element, and the browser must execute the action.
Keep the following assertions: pin confirms an action target, not the app's correctness.
3. Pin supports bounded explicit single-action forms (click, double/right-click, hover, type/fill, select, upload),
with quoted target names or control nouns. For exact forms and offline quoted-value rules, read
[references/record-replay.md](references/record-replay.md#pin-an-ambiguous-target) before pinning.
Checks, compound Steps, unknown continuations, dialog choices, drag destinations, action-table rows and shared
Background/Outline lines cannot be pinned. If refused, return to wording repair; keep the expected outcome fixed.
Commit reviewed cassette changes with the feature. `--record all` replaces pins; healing a changed Step replaces its
pin too. On `UI_CHANGED`, inspect the current UI before healing with `--record new` (calls Jev).
Done when the run passes with assertions intact (after pinning, verify with `--record none`), or every remaining
failure is classified as the app being wrong, with the evidence line from `report.md`.
Pliki w paczce (4)
- SKILL.md 9 KB
- references/record-replay.md 6 KB
- references/steps.md 17 KB
- references/troubleshooting.md 4 KB
Wersje
W bazie nie ma innych skilli o nazwie decisium.
Migawka bazy z 13.11.2026 · wersja paczki ef7c486a4e75 (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
- 100bdd-scenarios
Pisze scenariusze given-when-then w języku domeny, aby interesariusze mogli potwierdzić zachowanie chronione przez test, przy kryteriach akceptacji i funkcjach Gherkin dla reguł widocznych dla użytkownika. - 100gherkin-scenarios
Pisze czytelne dla biznesu scenariusze Gherkin (Given, When, Then) z kryteriów akceptacji i sprawdza je skryptem lintującym. - 100test-spec
Generuje specyfikacje BDD w Gherkin z przypadków użycia, przekształcając przepływy główne i alternatywne w scenariusze Given-When-Then oraz sprawdza pokrycie. - 100pwauto-scenarios
Projektuje scenariusze BDD w Gherkin na podstawie bazy wiedzy, z przypadkami granicznymi i tabelą śledzenia. - 100gherkin-from-stories
Zamienia wymagania w różnych formach na scenariusze Gherkin: user story, kryteria akceptacji ATDD z tagami @AC-N, istniejące kroki testów manualnych i fragmenty specyfikacji lub PRD. - 100acceptance-criteria-gherkin
Pisze kryteria akceptacji w składni Gherkin: scenariusze Given, When, Then, z przykładami i przypadkami negatywnymi.