QA Engineer

Shipping a project with a hidden bug is like sending a car out of the factory with no final inspection. Like a building inspector who walks every floor before people move in, QA Engineer checks the whole project before anyone uses it. A button that does nothing, or a page that turns blank in dark mode, can reach your users before you notice. QA Engineer is the inspector at the end of the line.

It runs every check your project has, one after another, and writes down what each one printed. You do not need to remember the commands or their order. You ask in plain words, and QA Engineer does the rounds for you.

It never says "passed" for a check it did not run. If something cannot run on your machine, it tells you so. When a fix fails after one try, it hands the problem to Support Engineer with the exact error and what it already tried. This saves you the most painful kind of day. Without a checker, you find out a build is broken from a customer's email, after the release is already out. With QA Engineer, you find out on your own screen, while the fix is still small and cheap.

• Run the type check (a check that finds data used the wrong way, before the app runs), the lint check (a style and mistake checker), the tests and the build (the step that packs your app up), in that order.
• Report each result exactly as it came out, so you see the real output and not a summary of it.
• Run a visual quality audit before production. It finds hardcoded colours that break dark mode and screens that have no loading or error message.
• Check that every page has a title and a description, so search results and shared links look right.
• Scan for accessibility gaps, such as images with no alt text (a short description for people who cannot see them), form fields with no label, and buttons with no name. Accessibility means how easy the app is for everyone to use, including people who rely on a screen reader, a tool that reads the page aloud.
• Write tests for key screens and for API endpoints when the project needs them. An API endpoint is a doorway where other programs send and receive data.
• Review code for quality when you ask, and check packages for old versions or known security problems, so you know which ones to fix first.
• Work with your GitHub, Linear, Jira and Postman accounts once you connect them, and use the Files, Review, Terminal and Browser panels to show you what it found.

The review skill checks the whole codebase for quality. It reads the project's file index first, which is a list of every file and what it does, so it knows where to look. Simpler projects get lighter checks. For example: "Review the code I changed today."

The update-deps skill checks your packages for old versions and known security holes, then updates them with care. A package is a ready-made piece of code your project borrows, like a part bought from a supplier. Old parts can break or leave a door open. The skill asks before it changes any package, because an update can change how the app behaves. For example: "Are any of our packages out of date or unsafe?"

The clone-test skill is for an app clone, which is a copy of an existing app built again from its screens and flows. It clicks through every flow, writes a test plan, automates the tests it can, and logs each bug with a severity, the steps to repeat it and proof. For example: "Click through the whole clone and tell me what is broken."

The clone-parity skill compares the clone with its original. It gives a score for how many features are covered, lists what is missing in build order, and compares screenshots while ignoring colour. A new brand colour does not count against the clone. For example: "How close is my clone to the original?"

You want to know if the project is safe to ship. Here is how it goes.

1. You ask, "Run all the checks before I deploy."
2. QA Engineer reads the project's settings to learn its scope and tools, and finds the test and build commands.
3. It runs the type check first, then the lint check, then the tests, then the build. The order matters. A type error often causes the build to fail, so it is best to find that first. It notes each result as it prints.
4. If one check fails, it reads the error and makes one fix. Then it runs that same check again.
5. If the second run still fails, it stops. It hands the error to Support Engineer along with what it already tried. It never keeps guessing, the way a cook should not keep changing a recipe that has already failed twice.
6. For a production project, it then runs the visual quality audit and lists every issue with its file and line number.
7. It asks before it deletes any file, changes a package or pushes code. You stay in charge of every change that is hard to undo.
8. It writes a short report: each check with PASS or FAIL, what it could not run, and what is still open. If your project keeps team notes, it also updates the dev log and the task status.
9. You get a clear answer. Either the project is ready to deploy, or you get a short list of what to fix first.

What you get at the end is a report you can read in a minute. It names every check, shows the result of each one, lists what could not be run, and points to the next step. Nothing is marked as passed unless it was run and seen to pass.