AutoReg: Skill Installer
One-click install of the AutoReg AI skills into any coding agent in your workspace — Claude Code, Cursor, GitHub Copilot, Windsurf, Continue, Devin, Roo Code, Cline, Kiro, Goose, Amazon Q, Gemini CLI, Codex CLI, Aider, Plandex, Antigravity, and more.
Four skills ship together, one command to run them:
- generate-autoreg is the entry point. It uses the open app source workspace, detects whether the app is a UI, an API, or both, and runs the matching generator. No workflow or app source path is requested.
- generate-ui-autoreg turns a UI app's source code into a rock-solid, signed
autoreg.md test specification that AutoReg uses to generate browser end-to-end tests that pass on the first run.
- generate-api-autoreg turns an HTTP API's source code — endpoints, request and response models, auth, error contracts — into a signed
autoreg.md API test specification that AutoReg runs over HTTP, no browser, with every input value as an editable test parameter.
- fix-autoreg-defect closes the loop the other way: when AutoReg finds that the application violates the spec, it files a defect; your coding agent picks it up with this skill, fixes the app, and reports back for AutoReg to verify.
How it works
Install the skills — open the AutoReg panel in the activity bar. The extension detects which agent tools exist in your workspace (.claude/, .cursor/, .github/, …) and installs all four skill files side by side, in the right place and format for each (slash command, rule, or prompt).
Run generate-autoreg in your agent — e.g. in Claude Code:
/generate-autoreg
The current workspace is the app source. The skill detects the project type and stores workflow files in .autoreg/ui/ or .autoreg/api/ with the single uploadable spec. Use --ui, --api, or --both to force a type. A combined app gets separate .autoreg/ui/autoreg.md and .autoreg/api/autoreg.md specs.
Answer a few questions — the generator asks for test credentials (or an API token), seed data, allowed writes, and sample values up front, then analyzes the entire codebase.
Get autoreg.md — a complete, self-verified spec. Import it into AutoReg to generate and run tests; AutoReg recognises which kind it is.
Signing is built into generation. The extension signs the workflow's autoreg.md and autoreg.delta.md (in delta mode) through the AutoReg cloud. The coding agent does not need to request a separate signing step.
Change your app, re-run it — the skill works incrementally from then on (see below).
Let AutoReg hand you the bugs — when a run fails because the app is wrong, AutoReg files a defect and this extension notifies you; one click launches your coding agent on it (see below).
Where your AutoReg workflow lives
The uploadable autoreg.md stays in the app source. Every workflow's .ar manifest, baseline, machine delta, signed delta report, plans, tests, runs, defects, and fix reports live under <app source>/.autoreg/<ui-or-api>/. The desktop app and extension calculate this path identically. When you create a workflow in AutoReg, its name becomes the .ar manifest name in that folder. The workflow files are available in your source tree.
Incremental updates (delta mode)
The first run saves a baseline of your app to the source workflow's baseline.json, together with the spec kind. Later runs use that baseline for UI and API deltas.
Re-run the same command after changing your app and the skill does a functional diff instead of starting over:
- Detects what changed by hashing your source against the baseline (git is used when present, for rename detection, but is never required)
- Traces the impact through a dependency graph — if a shared component or auth flow changes, the features downstream of it get re-verified too
- Touches only the affected scenarios — new ones for new functionality, updates where a selector or error message moved, removals for deleted features. Scenarios nothing touched are carried through byte-for-byte, so working tests stay working
- Never duplicates — every scenario carries a coverage key, and one intent can only ever have one active scenario
You get an updated signed workflow autoreg.md, a signed workflow autoreg.delta.md showing what changed, and a workflow delta.json. In AutoReg, ask the agent to "apply the spec delta": it verifies signatures and hashes, then previews every add, update and delete before changing tests.
Already have an autoreg.md from an earlier version? Just re-run — the skill adopts your existing spec as the baseline without rewriting your scenarios.
Pass --full to force a complete rebuild (scenario IDs are preserved across it).
The feedback loop (fix-autoreg-defect)
Every failed run in AutoReg is triaged first: is the test wrong, or the app? AutoReg checks whether the spec explicitly states the failed expectation, whether the scenario passed before with the same test, what the app itself reported (console and page errors, failed requests, 5xx responses are captured during every run), and whether your source changed since the spec was generated. An app defect is never "healed" by rewriting the test. Instead, with your approval, AutoReg files it:
<workflow>/defects/DEF-0003.json the spec's expectation, the failing step, the feature's source files,
<workflow>/defects/DEF-0003/ screenshot, live page snapshot, captured console/network errors
Run /fix-autoreg-defect from the app source workspace. The skill finds open defects in the matching source workflow. Reggie still shows the defect path for reference.
In VS Code, AutoReg: Fix a Defect… finds open defects for this workspace, lets you pick an agent with a CLI (Claude Code, Codex, Gemini CLI, Aider, Goose, Plandex) and opens a terminal with it started on the defect, or copies the prompt for IDE-only agents. The skill claims the defect, reads the evidence, traces the failing step to the code, fixes the application (never the test or the spec), re-runs generate-autoreg in delta mode if the fix changed behaviour, and writes fixes/DEF-0003.fix.json. Back in AutoReg, say "verify fixes": it applies any pending spec delta, re-runs the scenario and the features that depend on it, and resolves or reopens the defect. Each side writes only its own files; nothing is filed, verified or resolved without your click.
Live connection over MCP
While a workflow is open, the AutoReg app serves the same defect tools over MCP on localhost. Click MCP next to an agent in the panel (or run AutoReg: Connect a Coding Agent over MCP); the extension finds the matching source workflow, copies a dependency-free stdio shim into <workflow>/mcp/, and merges an autoreg server into the agent's project-level config — .mcp.json (Claude Code), .cursor/mcp.json, .vscode/mcp.json (Copilot), .kiro/settings/mcp.json, .gemini/settings.json, .amazonq/mcp.json, .roo/mcp.json, .continue/mcpServers/autoreg.yaml. Other servers in those files are left untouched. Your agent can then read defects, claim one, submit its fix report, and re-run the scenario live (AutoReg asks you to allow that the first time). When the app is not running the shim answers with a "not running" status instead of hanging.
- Confirmed selectors, tier-ranked —
data-testid → id → form semantics → aria → text — with unreliable selectors (hashed CSS-module classes, styled-components hashes, generated ids) explicitly blocked
- Every route across React, Next.js, Remix, Vue/Nuxt, Angular, Svelte, Astro, Rails, Django, Laravel, Spring, ASP.NET, plain HTML, and REST APIs — including auth requirements per route
- Domain types and validation schemas (verbatim) — powering realistic generated test data and exact-error-text negative scenarios
- Page behaviours — loading/transition patterns, network vs. client-side interactions, debounced search, modals, toasts
- Auth flows — login/logout/registration steps, role matrix, fresh-user pattern
- Test Data Catalog — user-provided, seeded, and generated values; secrets stay as
{{placeholder}} tokens that AutoReg resolves at import time
- 8–25 self-contained test scenarios — positive and negative, using only confirmed selectors and catalogued data, self-verified before the file is written
- Cryptographic signature — the finished file is signed by the AutoReg cloud (Ed25519); the AutoReg app requires a verified signature to create a workflow
- Every endpoint across Express, Fastify, NestJS, Hono, Koa, Next.js / Nuxt / SvelteKit API routes, tRPC, GraphQL, FastAPI, Django REST, Flask, Rails, Laravel, Spring, ASP.NET and Go — method, full path, auth requirement, request and response models, every status it can return, side effects, idempotency. An OpenAPI file is read first and confirmed against the code
- Request and response models (verbatim) plus a validation table — field → rule → the exact status and error message the API returns — powering one negative scenario per rule
- Error contracts — the global error envelope and every message string, so negatives assert exactly what the API says
- Auth and roles — the token flow as concrete request/response pairs, how the token is sent, the role matrix
- Behaviours — pagination, filtering, ordering dependencies (create → read → delete), idempotency keys, eventual consistency
- Test Data Catalog — every body, query and header value is a
{{token}}; secrets stay pending until you set them in AutoReg's Test Parameters, and any value can be overridden per scenario without regenerating
- 8–30 self-contained scenarios — each obtains its own token, creates what it reads, cleans up what it created; 400 / 401 / 403 / 404 / 409 negatives with exact codes and messages
- Same signature, same delta mode — the file signs and verifies exactly like a UI spec; re-runs regenerate only the scenarios your API changes touched
Extension features
- Sidebar panel — see every supported agent tool, which are detected in the workspace, and install/update/open/remove the skills per tool (a workspace with an older single-skill install shows Install missing)
- Fix a Defect… — choose an open defect for this app source and launch your coding agent on it
- Status bar — installed-skill count at a glance
- Auto-detect — prompts once when an agent folder exists but the skills aren't installed (
autoreg.autoDetect setting)
- Commands —
AutoReg: Install AutoReg Skills, AutoReg: Open Installed Skill File, AutoReg: Show Skill Usage Instructions, AutoReg: Fix a Defect…, AutoReg: Connect a Coding Agent over MCP
- Fallback mode — no agent folder? The skills are saved to
generate-autoreg/ so you can attach them to any AI agent as context (keep the three generate-* files together — the router reads its siblings from the same folder)
Requirements
- An AI coding agent (any of the tools above)
- An app source workspace; AutoReg creates the
.ar manifest when the signed spec is imported
Settings
| Setting |
Default |
Description |
autoreg.autoDetect |
true |
Prompt to install when agent folders are detected |
autoreg.skillFileName |
generate-autoreg |
Deprecated — not read. The entry point is always generate-autoreg; its siblings have fixed names |
autoreg.cloudUrl |
(empty) |
Override the AutoReg cloud base URL used for spec signing |
License
See LICENSE.
| |