Skip to content

Skills — Index and technical reference

This section is the technical reference for every skill available in the NEO project. If you're not yet clear on what a skill is (as opposed to a playbook), start with Playbooks vs. Skills — this page assumes you already know that difference and goes straight to the details of each skill: when it's triggered, what information it needs to run, and what it gives you back.


1. How to read each entry

Each skill has its own entry, always with the same structure:

Field What it means
When to use it The specific situation that triggers this skill — when it makes sense for you to invoke it directly, or when a playbook/plan will invoke it for you.
Required inputs The data the skill can't start without. If any of them is missing, the skill stops and tells you — it never "makes up" a value.
Optional inputs Data that changes or enriches the behavior, but that has a default value or an alternative path if it's not provided.
Output What the skill delivers when it finishes — the concrete result that another skill (or you) will use next.
Chains with Which skill typically runs before and which one runs after, when that's defined.

The field names (input.algo, config.algo) are technical — they're meant for whoever builds plans or playbooks. If you talk to the skill in natural language, you don't need to name them: the assistant fills them in for you based on what you tell it.


2. Skills grouped by use

The project's 39 skills are grouped into 13 categories, according to the type of work they handle within the QA flow. They roughly follow the order in which they act within a typical flow: first the source is read, then it's classified/planned, then it's explored or executed, and finally it's reported.

Some skills exist specifically for the orchestration models M2 (Adaptive hybrid: the assistant classifies the request and chooses among already-written plans) and M4 (Pure declarative: a fixed rule, for example a CI job, triggers a plan without anyone deciding at the moment). Those are invoked by the NEO engine within a plan, not by a person, so you normally won't need to call them by hand.

Nested skills = subskills

The skills that appear nested under another one in the table are subskills: they're used by the skill they depend on to handle a specific part of its work — for example, exporting to a specific tool (Xray…) or fetching the story from a specific system. You don't need to invoke them directly: you invoke the skill they depend on, and that skill chooses the subskill that fits based on the qa-stack.yaml configuration or where the data comes from.

Some skills handle the per-tool variants without subskills: they keep what's specific to each tool in reference files inside their folder (references/) and read only the one that applies. That's the case of lippia-neo-report-bug, which publishes to Jira, Azure DevOps, GitHub, or GitLab from a single skill.

Category What it's for
📥 Reading and ingestion Fetch and normalize the user story or bug that the rest of the flow will work with, regardless of whether it lives in a local file, in Jira, or in Azure DevOps. Also read an already-written test plan as structured data.
  • lippia-neo-read-user-story
    • lippia-neo-fetch-user-story
  • lippia-neo-read-bug-report
  • lippia-neo-resolve-user-story-source
  • lippia-neo-read-test-plan
🧭 Classification and routing Decide, without human intervention, which plan to run for a free-text request (M2 orchestration model), and build the input that plan needs.
  • lippia-neo-classify-task
  • lippia-neo-build-plan-input
  • lippia-neo-classify-ui-scope
⚙️ Configuration and infrastructure Get a new project ready to work with NEO: detect its technical stack and generate the CI pipeline that runs the tests automatically. It's the first thing you need to run if the initial NEO configuration hasn't been done in the project yet (there's no qa-stack.yaml), starting with lippia-neo-bootstrap-stack.
  • lippia-neo-bootstrap-stack
  • lippia-neo-ci-bootstrap
🗺️ Test planning Turn a story (or a broad exploration request) into a concrete plan of what to test: step-by-step scenarios, or a bounded portfolio of exploratory charters selected based on the available context.
  • lippia-neo-create-test-plan
  • lippia-neo-discover-exploratory-areas
  • lippia-neo-create-exploratory-charters
📤 Test case export Normalize a plan's scenarios into a tool-agnostic test case format and export them to the test management tool configured in test_management (currently Xray Cloud).
  • lippia-neo-meta-normalize-test-cases
  • lippia-neo-meta-export-test-cases
    • lippia-neo-export-test-cases-xray
🔎 Exploration Navigate the real application (with Playwright MCP) to validate a plan, confirm whether a bug reproduces, or run a free charter-style exploration session, documenting findings with evidence.
  • lippia-neo-run-manual-testing
  • lippia-neo-reproduce-bug
  • lippia-neo-run-exploratory-session
🧩 Existing coverage Before generating anything new, find out what's already covered by existing tests — per story/bug or per a PR's diff — and which scenarios remain uncovered.
  • lippia-neo-find-existing-tests
  • lippia-neo-find-ui-tests-by-code-diff
  • lippia-neo-review-test-coverage
⚡ Automated execution Generate the executable test suite, run it, and automatically repair what fails for minor reasons (broken selectors, timeouts, etc.). Also restructure an existing Gherkin suite so it is data-driven.
  • lippia-neo-generate-test-suite
  • lippia-neo-run-and-heal
  • lippia-neo-repair-selectors-by-diff
  • lippia-neo-refactor-gherkin-features
🚀 Performance testing Go from an API collection to load tests: read the collection, generate k6 or JMeter scripts (smoke, load, stress, spike), run them profile by profile and write the final report.
  • lippia-neo-read-api-collection
  • lippia-neo-generate-k6-script
  • lippia-neo-generate-jmeter-script
  • lippia-neo-run-performance-test
  • lippia-neo-write-performance-report
📊 Reporting Consolidate the results of exploration, generation, and execution into a final document, timestamped and without overwriting previous reports.
  • lippia-neo-write-test-report
  • lippia-neo-write-generation-report
  • lippia-neo-write-exploratory-testing-report
🐞 Bug management Turn the findings of an exploration, reproduction, or execution into BUG-NNN.json files and publish them, without duplicates, to the configured tool (Jira, Azure DevOps, GitHub, or GitLab).
  • lippia-neo-generate-bug
  • lippia-neo-report-bug
🎬 Full-flow orchestration Meta-skills that chain several of the skills above, in a fixed order, to handle an end-to-end flow in a single invocation.
  • lippia-neo-meta-run-user-story-e2e
  • lippia-neo-meta-run-exploratory-testing
✅ Governance and human approval Leave an explicit pause so a person can approve or reject an artifact before the flow continues.
  • lippia-neo-relay-human-approval

3. Am I looking for a single skill or a playbook?

I already know which specific step I need

For example: "I just want to read this story" or "I just want to run and repair the tests". Look for the skill in the matching category in the table above.

I have a whole situation to solve

A PR, a bug, a deploy, a new story. You'll probably be better off with a playbook, which already chains the right skills in the right order — with human checkpoints where needed.


4. Skills repository

The source code of these skills (the SKILL.md files this reference is based on) lives in the NEO-releases repository:

https://gitlab.crowdaronline.com/lippia/products/neo/neo-releases.git

If a skill changes its behavior, this reference may become outdated until the next review — if in doubt, the original SKILL.md is the source of truth.