Skip to content

Neo by Crowdar

Home

Welcome to the NEO user manual. This manual brings together, in one place, everything you need to understand how it works, set it up, and use it day to day — with no need to know how to code or have any prior technical knowledge.


1. Introduction

NEO is a set of "skills" (tools) that a compatible AI assistant (Claude Code, Codex, or GitHub Copilot) uses to automate QA work end to end: read a user story, put together a test plan, explore the application, generate automated tests, run them and repair them if they fail, and write the final report. See the compatibility table in Requirements and setup for the details of each assistant.

That work can be triggered in 4 different ways (see The 4 orchestration models), and for frequently repeated flows there are playbooks — step-by-step recipes already written that make sure the result is always the same, no matter who asks the assistant.

This manual documents:

  • The general concepts of the system (how the work is orchestrated, what a playbook is vs. a skill, how to install and update it).
  • Each available playbook, explained in simple language: what it does, when to use it, and what information you need to give the assistant.
  • Each available skill, in detail: what it does, what data it needs, how it works step by step, and what it delivers.
  • Each engine plan: the automated version of a flow, which the NEO engine runs on its own (for example, from the pipeline), with no AI assistant and no person on the other side.

2. How to use this manual (and why)

Instructions — how to read this manual

  1. If this is your first time, start with Requirements and setup and then Playbooks vs. Skills. Those two documents give you the minimum vocabulary to understand everything else.
  2. Continue with The 4 orchestration models to understand who decides the workflow and who runs it in each case.
  3. Go to the "Guides" section only when you need to run a specific playbook (for example, you're about to run a post-deploy smoke test, or you're going to fix a bug). You don't need to read them all in advance — they're meant to be consulted at the moment you use them, like a recipe.
  4. If something doesn't start (MCP connection, outdated version of the repo), check Playwright MCP setup or How to get the latest version first before assuming it's a bug in the system.

You don't need to read the manual from start to finish: each guide is written so it can be read on its own, with no prior technical knowledge.

Rationale — why this manual exists

This manual exists because AI-driven QA work is only reliable if anyone on the team, whether or not they have a technical profile, can understand what the assistant is going to do before asking for it, and then verify that it did what it said it would do. Without that transparency, a playbook stops being a "reproducible recipe" and becomes a black box.

That's why every guide in this manual:

  • Uses simple language, without programming jargon, even when it describes something technical under the hood.
  • Explains what information you need to give the assistant for the result to turn out well, not just what the assistant does.
  • Documents the rationale behind each design decision (why there are 4 models and not just one, why a playbook is different from asking the assistant for something on the fly) so that the team's future decisions rely on that same criteria instead of being reinvented every time.

3. Where do I start, depending on my situation?

Your situation Document to read
I've never used NEO and I need to install it Requirements and setup
I don't understand the difference between a "skill" and a "playbook" Playbooks vs. Skills
I want to understand who decides the workflow (AI, person, fixed rule) The 4 orchestration models
My copy of the repo is out of date How to get the latest version
The Playwright MCP doesn't connect / exploration fails Playwright MCP setup
I need to configure Playwright, Lippia, Cypress, or Pytest so NEO can use them Configuring the adapters
I need to connect the MCPs (Playwright, Jira, Azure DevOps) to my IDE or desktop app Configuring the MCPs
I want to run NEO without an AI assistant, from the terminal or a pipeline (Models 2 and 4) The NEO engine
I want to know what an engine plan does, or how it differs from a playbook Plans
I want to write or modify an engine plan Anatomy of a plan and Composition patterns
I want NEO to run on its own in the pipeline (GitLab, GitHub, or Bitbucket) Configuring CI
I need to run a specific playbook Look it up in the guide index below
I need to know what inputs a specific skill needs, or what it returns Skills — Index and technical reference

4. Index — General concepts

Guide What you'll learn
Requirements and setup What you need installed on your computer to work with NEO.
Getting started The numbered, step-by-step guide to getting your computer ready to work with NEO for the first time.
Playbooks vs. Skills The difference between asking the assistant for something on the fly and following a recipe that's already written.
The 4 orchestration models The 4 ways QA work can be started and run, with code examples in Playwright and Lippia.
How to get the latest version How to update your local copy of the repository when the team pushes changes.
Playwright MCP setup How to fix the most common connection issues when setting up the Playwright MCP.
Configuring the adapters How to configure Playwright, Lippia, Cypress, or Pytest so NEO can generate, run, and repair the tests.
Configuring the MCPs How to connect the NEO MCP servers in the IDE (Claude Code, Copilot, Codex, Cursor), in desktop apps (Claude Desktop, ChatGPT Desktop, Copilot app), and in the terminal.
The NEO engine What the engine is, its requirements, how to run it, how Models 2 and 4 work under the hood, how to write a plan, and the 7 composition patterns.
Plans What a plan is, how it differs from a playbook (a plan is run by the engine; a playbook, by the AI assistant), and what each available plan does.
Configuring CI How to generate and configure the NEO pipeline in GitLab CI, GitHub Actions, and Bitbucket Pipelines: files, variables, labels, and the limitations of each platform.
Skills — Index and technical reference The details of every skill in the project, grouped by use: when it's triggered, what information it needs, and what it returns.

5. Guide index (by playbook)

Playbook When to use it
New Project Bootstrap You're going to prepare a new project to start doing QA on it.
Feature - New End-to-End There's a new feature and you need to cover it with tests from scratch.
Bug Reproduction You need to confirm and document that a reported bug really happens.
Bug Fix Cycle You need to fix a bug and prove, with tests, that it's been fixed.
Business Rule Change An already documented business rule changed on purpose (it's not a bug) and you need to update whatever that change affects.
Frontend UI Change PR There's a frontend PR and you need to decide whether it calls for a smoke test or a full UI regression.
Exploratory Testing Portfolio You need to explore an application (or a large part of it) without a fixed script, with time-boxed sessions and a consolidated report.
Smoke Test Post-Deploy A deploy just happened and you need to quickly confirm that nothing broke.
Hotfix Fast Track You need to validate an urgent fix before releasing it, as quickly as possible.
Demo Walkthrough You need to show a client or stakeholder how a feature was tested.

5.1 Skills catalog

The skills are documented by category in the Skills catalog:

Category Skills
Configuration and infrastructure lippia-neo-bootstrap-stack, lippia-neo-ci-bootstrap
Reading and ingestion 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 lippia-neo-classify-task, lippia-neo-build-plan-input, lippia-neo-classify-ui-scope
Planning lippia-neo-create-test-plan, lippia-neo-discover-exploratory-areas, lippia-neo-create-exploratory-charters
Existing coverage lippia-neo-find-existing-tests, lippia-neo-find-ui-tests-by-code-diff, lippia-neo-review-test-coverage
Exploration lippia-neo-run-manual-testing, lippia-neo-reproduce-bug, lippia-neo-run-exploratory-session
Automated execution lippia-neo-generate-test-suite, lippia-neo-run-and-heal, lippia-neo-repair-selectors-by-diff
Orchestration lippia-neo-meta-run-user-story-e2e, lippia-neo-meta-run-exploratory-testing
Reports lippia-neo-write-test-report, lippia-neo-write-generation-report, lippia-neo-write-exploratory-testing-report
Bug management lippia-neo-generate-bug, lippia-neo-report-bug
Test case export lippia-neo-meta-normalize-test-cases, lippia-neo-meta-export-test-cases, lippia-neo-export-test-cases-xray
Governance lippia-neo-relay-human-approval

5.2 Plan index

Plans are flows that the NEO engine runs on its own, usually from the CI pipeline. Many of them are the automated version of a playbook. See Plans for the full comparison.

Plan When it runs Related playbook
Feature - New End-to-End An MR is opened with the feature label: a new feature has to be tested from scratch. Feature - New End-to-End
QA Bug Coverage A bug moves to QA: confirm it reproduces and leave a test that captures it. Bug Fix Cycle
QA Bug Fix Verification The developer applied a bug's fix: verify its tests now pass. Bug Fix Cycle
UI Selector Repair A frontend change renamed selectors: fix the affected tests before deploying. Frontend UI Change PR

6. Project repository

The NEO code and documentation live in GitLab:

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

If you need to clone it for the first time or pull the latest changes, see How to get the latest version.

Current version of this manual: v1.0.0


If you can't find the playbook you need, or the flow you're looking for doesn't have a written recipe yet, you can ask the assistant directly in natural language — that's Model 1 (Improvised), described in The 4 orchestration models.