Catalogue complet des skillsComplete skill catalogue

Audits the actors of a `.smartstack/ba/` project — existence, duplicate names (case-insensitive), missing type (ACT-001..006). Actors are PROJECT-scoped, so it reads every `<APP>/acteur.md` plus the menu tree, applies the rules, and writes a verdict to `_audit/actors.md` at the project root. Run after `/ba-create-actors` or as part of pre-dev readiness.

Cross-dimension coherence audit of one `.smartstack/ba/` module — verifies that data-model fields with state semantics have matching business rules, use cases and screens, that use-case actors exist in RBAC, and that screen entity refs resolve (XD-001..005). Reads the module's `entité.md`, `règles-métier.md`, `use-case.md`, `rbac.md` and its section `screen.md` files together, writes a verdict to `_audit/cross-dimension.md`. Run after the per-dimension audits or as part of pre-dev readiness.

Cross-references the BA data model of a module against the EXISTING project code — detects entities that extend an existing class, reference a Core/existing entity as FK, or duplicate one (CODE-001..004). Reads the module's `entité.md`, scans `src/*.Domain/**/*.cs`, writes a verdict to `_audit/cross-ref-code.md`. Run after `/ba-create-data-model` or as part of pre-dev readiness.

Audits the conceptual data model (MCD) of a `.smartstack/ba/` module — attributes, FK integrity, cycles, naming, orphans, traceability, indexes, implicit FKs, unreferenced lookups, classification conventions, code-pattern numbering (DM-001..017). Reads the module's `entité.md` + `use-case.md` + `règles-métier.md`, writes a verdict to `<MODULE>/_audit/entité.md`. Run after `/ba-create-data-model` or as part of pre-dev readiness.

Audits the menu (Application / Module) of a `.smartstack/ba/` project — module semantics, cross-app duplicates, SmartStack Core collisions, orphans/empty, out-of-scope coherence (MENU-001..005). Reads the tree, writes a verdict to `_audit/menu.md`. Run after `/ba-create-menu` or as part of pre-dev readiness.

Audits the on-disk PRD of ONE module in a `.smartstack/ba/` project — the largest audit (70 checks across 7 dimensions: structure, completeness, clarity, consistency, traceability, feasibility, slices + per-page contract + custom-action contract). Reads `prd.md`, the three `prd.*.md` slices and the `pagespecs/*.md` blocks against the upstream BA docs, then writes a verdict to `_audit/prd.md` carrying the dev-readiness gate (`GO|NO-GO`). GO is the gate `/ba-develop` reads. Run after `/ba-create-prd`.

Pre-development readiness orchestrator for a `.smartstack/ba/` project. Does NOT re-run any dimension's rules — it reads the per-dimension verdicts already written under `_audit/*.md`, aggregates them across every module and the 8 dimensions, and writes a project-readiness summary with an overall GO / NO-GO. Run after the `/ba-audit-*` dimension audits, before `/ba-create-prd` + development.

Audits the RBAC permission matrix of a `.smartstack/ba/` module — minimum permissions, segregation of duties, actor coverage and reference integrity (RBAC-001..005). Reads the module `rbac.md`, the app `acteur.md` and the section `use-case.md`, writes a verdict to `_audit/rbac.md`. Run after `/ba-create-rbac` or as part of pre-dev readiness.

Audits the business rules of a `.smartstack/ba/` module — completeness, conflicts, redundancy, example quality, entity/UC references, per-ruleType edge-case coverage (BR-001..010). Reads `règles-métier.md` plus the module's `use-case.md` and `entité.md`, writes a verdict to `_audit/règles-métier.md`. Run after `/ba-create-business-rules` or as part of pre-dev readiness.

Audits the screen specs of a `.smartstack/ba/` section — coverage, entity refs, SmartComponent coherence, navigation integrity, related-tabs, home-page hierarchy, UC traceability, custom-actions structure (SCR-001..013). Reads the section `screen.md` plus the module `entité.md`/`rbac.md` and the section `use-case.md`, writes a verdict to `_audit/screen.md`. Run after `/ba-create-screen` or as part of pre-dev readiness.

Audits the menu sections of a `.smartstack/ba/` project — module-section coverage, duplicate/ambiguous/empty sections, cross-module and cross-app duplication (SEC-001..006, XAPP-001..003). Reads the section nodes under a module, writes a verdict to `_audit/sections.md`. Run after `/ba-create-menu` or as part of pre-dev readiness.

Audits the use cases of a `.smartstack/ba/` module — completeness, step quality, vague language, scope respect, actor references, redundancy (UC-001..012). Reads the section `use-case.md` files + the app `acteur.md`, writes a verdict to `<MODULE>/_audit/use-case.md`. Run after `/ba-create-use-case` or as part of pre-dev readiness.

Phase 2 of business analysis. Defines the project's actors (roles) that interact with the applications, and writes them to `acteur.md` at the Application level under `.smartstack/ba/`. Conversational: reads the menu tree and existing actors, proposes coverage per app, asks the user to validate, then writes the file. Run after the menu (`/ba-create-menu`), before use cases.

Phase 4 of business analysis. Captures, classifies and elaborates structured business rules (with concrete valid + invalid examples) and writes them to `règles-métier.md` under `.smartstack/ba/`. Conversational: reads the menu tree, actors and use cases, proposes rules, asks the user to validate, then writes the file. Run after use cases (`/ba-create-use-case`), before RBAC.

Phase 6 of business analysis. Builds the conceptual data model (MCD) of each business module — entities, attributes, computed formulas, relationships and indexes — and writes it to `entité.md` at the Module level under `.smartstack/ba/`. Conversational: reads the menu tree plus the module's use cases and business rules, deduces the entities, asks the user to validate, then writes the file. Run after RBAC (`/ba-create-rbac`), before screens (`/ba-create-screen`).

Phase 1 of business analysis. Builds the Application → Module → Section → Resource menu hierarchy for a project as a folder tree of `index.md` files under `.smartstack/ba/`. Conversational: reads the current tree, proposes the next level, asks the user to validate, then writes the files. Run this first, before defining actors, use cases, rules, RBAC, data model, or screens.

Generates a phased development plan ordering modules by their cross-module data-model dependencies. Reads entité.md across selected applications, builds a dependency graph, topological-sorts into parallel development waves, and writes dev-plan.md. Invoke between the BA audit phase and /ba-develop.

Synthesises the upstream BA `.md` tree of ONE module (menu, actors, use cases, business rules, RBAC, data model, screens) into a Product Requirements Document on disk: `prd.md` (framing + user stories), three phase slices, per-screen `pagespecs/*.md` (each carrying a machine spec block), and `claude.md`. The output drives development through `/ba-develop`. Run after the BA phases (and `/ba-audit-pre-dev` GO), before development.

Phase 5 of business analysis. Defines the RBAC permission matrix (who can do what) for each module and writes it to `rbac.md` at the Module level under `.smartstack/ba/`. Conversational: reads the menu tree, actors, use cases and rules, proposes coverage per actor × action, asks the user to validate, then writes the file. Run after business rules (`/ba-create-business-rules`), before the data model (`/ba-create-data-model`).

Phase 7 of business analysis (the LAST BA phase). Designs the UI screens of each section as SmartComponents (SmartListView, SmartForm, SmartDashboard, SmartKanban, SmartSectionHome, …) and writes them to `screen.md`, authoritative at the Section (and Resource) level under `.smartstack/ba/`. Each screen binds one entity, a permission and the use cases it serves. Conversational: reads the section's data model / RBAC / use cases, proposes screens, asks the user to validate, then writes the file. Run after the data model (`/ba-create-data-model`); hands off to PRD generation (`/ba-create-prd`).

Phase 3 of business analysis. Turns each section's scope into Cockburn-style business use cases (primary actor, preconditions, main / alternative / exception flows, postconditions), written to `use-case.md` at the Section level under `.smartstack/ba/`. Conversational: first has the user choose the application → module → section to work on, then reads that section's actors and existing use cases, proposes use cases, asks the user to validate, then writes the file. Run after actors (`/ba-create-actors`), before business rules (`/ba-create-business-rules`).

Pass 2 of the optional Two-Pass fast-modeling path. Take a SINGLE inventory item flagged `moderate` or `complex` (from a scope's `_inventory.md`) and expand it into a fully-detailed use case (Cockburn flows, pre/postconditions) or business rule (expression + concrete valid/invalid examples), then write it into the authoritative doc (`use-case.md` for a UC at its section, `règles-métier.md` for a rule at its scope) under `.smartstack/ba/`. Reads the inventory + the authoritative doc + `acteur.md`; writes by appending/Editing the doc while preserving every existing item.

Pass 1 of the optional Two-Pass fast-modeling path. In ONE fast pass, emit a lightweight inventory of ALL candidate use cases + business rules for a scope (application / module / section), each flagged `simple | moderate | complex` so a detail pass can route effort. Reads the `.smartstack/ba/` menu tree + actors for context and writes a planning checklist to `.smartstack/ba/<scope>/_inventory.md`. Hands off to `/ba-modeling-detail`.

Audit code generated by the API phase against the PRD slice — controllers, routes, HTTP actions, RBAC attributes, DTOs, integration tests

Audit code generated by Phase 0 (Core Foundation Seed) — every PRD module must have nav + roles + permissions in the 5 Core providers, DI registration must be in place, and the providers must be deterministic (no hand-edits).

Audit code generated by the Data phase against the PRD slice — migrations, seed providers, navigation/permissions coverage, FK constraints, drift detection

Audit code generated by the Domain phase against the PRD slice — entity files, FK pairing, naming, traceability, drift detection

Generates real test suites per architectural layer with business rule coverage, consuming NuGet (xUnit, FluentAssertions, Moq, FluentValidation.TestHelper) and npm (Vitest, Testing Library, React Query) packages.

Development workflow index — drives module development from PDR to production-ready SmartStack extension (NuGet + npm) with mandatory tests at every layer.

Audit du code genere contre les conventions SmartStack (i18n, React, structure, routing dynamique, RBAC, securite)

Audit READ-ONLY des skills de developpement SmartStack pour verifier leur conformite a l'architecture de routing dynamique DB-driven (PageRegistry + componentRegistry + DynamicRouter). Produit un rapport textuel sans modifier aucun skill.

Generates full CQRS stack — Commands, Queries, Handlers, DTOs, Validators, Service interface + implementation — on SmartStack NuGet abstractions (ICoreDbContext, MediatR, FluentValidation).

Generates API controllers with NavRoute, RequirePermission, auto-mapped DTO → Command conversions, and module-scoped permission classes, consuming NuGet packages (SmartStack.Core, SmartStack.Api, MediatR).

Phase 0 of /ba-develop — generates one Core Foundation Seed bundle per declared application (5 IClientSeedDataProvider classes per app covering navigation + roles + permissions + role-permission mappings + dev test users) by invoking the deterministic `scaffold-core-seed` CLI. Zero creative work for the agent: the spec is built by the Studio backend (`prepareCoreSeedContext`) from the BA menu / actors / permissions and dropped to a temp file before this skill runs.

Generates Domain entities with BaseEntity (SmartStack.Core.Domain NuGet), domain events, soft-delete, EF Core configurations with schema targeting, and migrations.

Generates module-scoped IClientSeedDataProvider implementations for reference data (lookup tables, enum codes) and per-module overrides. Cross-app navigation, roles, permissions, and role-permission mappings are NOT this skill's job — they live in scaffold-core-seed (Phase 0). Output goes under Persistence/Seeding/Applications/{AppPascal}/Modules/{ModuleCode}/ to mirror the per-application module layout.

.NET Clean Architecture 4-layer SmartStack

Refine a user-reported bug — rephrase, classify, and cross-reference the code in the current worktree.

Diagnose and auto-fix SmartStack dev-runner issues (backend + frontend)

Diagnose and auto-fix SmartStack .NET backend failures

Diagnose and auto-fix SmartStack React+Vite frontend failures

Conversational triage on a tracked bug — answer the user, decide whether to reopen the fix or re-audit, never modify code directly.

Implement a fix for a user-reported bug — edit code, verify, commit atomically with a traceable message.

Generates TypeScript service clients + React Query hooks using smartstackClient (shared axios instance from @atlashub/smartstack npm package) and direct REST paths (/api/{module}/{plural}).

Scaffold the per-project useAuth hook + PermissionGuard component

Generates React page components (list, detail, form) consuming @atlashub/smartstack npm package: PermissionGuard, Slot, SmartStackProvider. i18n keys are split per entity to prevent concurrent-generation overwrites.

Generates ExtensionConfig (@atlashub/smartstack) with slot definitions that mirror the <Slot name="..."> calls emitted by frontend/component.

Generates PageRegistry registrations for SmartStack's DB-driven routing (DynamicRouter). Validates componentKey format before emission and fails loud on bad specs rather than producing silent-spinner registries.

React + Vite + Tailwind + SmartStack frontend structure (npm consumer of @atlashub/smartstack)

Audits and auto-fixes React pages in a generated SmartStack frontend against the customisation-ui design system standards (CSS variable tokens, PageTemplate wrapper, DataTable/EntityCard components, lucide-react icons, semantic badges, permission keys, i18n namespaces). Produces a violation report (audit mode) or applies mechanical fixes (apply mode) based on tokens.json. Invoked after Phase 4 of ba-develop to guarantee visual consistency with the reference app.

Kill orphans + launch backend + frontend, auto-retry on failure

Kill stale .Api processes, launch dotnet run, verify /health — retry loop

Kill stale Vite, npm run dev, verify /, retry loop

Runtime smoke-test for a freshly-generated SmartStack.app project. Starts the backend (`dotnet run`) and the frontend (`npm run dev`) in the background, waits for both to become reachable, then probes every page route and every API endpoint scaffolded by the pipeline. Fails the run if ANY endpoint returns a 4xx/5xx status code or if any page is missing from disk. Designed to be the final gate of `ba-develop` so cross-stack drift surfaces in CI rather than at the user's first manual `npm run dev`.

Auto-correct a SINGLE compilation error surfaced by the Studio's Dev Runner (dotnet CS####, tsc TS####, vite resolve). The caller provides one `BuildError` with file/line/column/code/message. Your job is to apply the MINIMUM patch to make that specific error go away, without refactoring surrounding code. Invoked by `build-fix-runner.ts` in a retry loop (max 15 iterations, convergence guard, rebuild-and-reparse after each attempt).

Phase 5 UI tests — drives dev-browser to navigate every scaffolded page, submit forms with role-based seeded users, and auto-correct failures via the existing fix-bug skill loop (max 50 iterations per test). Runs after the frontend scaffolders complete (routes + component + api-client + extension-config) and verifies the full backend ↔ frontend round-trip.

HTTP smoke prober for generated SmartStack applications. Given a list of URLs (frontend routes + backend API endpoints), fetches each one, follows redirects, applies retry-on-startup, and returns a JSON report of 200/non-200 results. Invoked after Phase 4 of ba-develop to detect broken routes and missing API endpoints before the user ever sees a 404 in the browser.

Audit code generated by the Frontend phase against the PRD slice — page coverage, registry wiring, lazy-import integrity, i18n namespaces, drift detection

Scaffold the app-level layout shell (PageTemplate + AppShell) reading nav from /api/navigation/menu, honoring per-app branding via @customised marker.

Bootstrap src/index.css with Tailwind v4 + Shoelace token overrides + design tokens from the PRD theme slice (or SmartStack defaults). Idempotent overwrite.

Consumes a module's PRD on disk (`prd.md` + 3 phase slices + `pagespecs/*.md` under `.smartstack/ba/<APP>/<MODULE>/`) and drives development through 4 sequential phases (Core Foundation Seed → Entities → API → Frontend), each running as a subagent. Phase 0 is deterministic — the agent invokes scaffold-core-seed to write the per-app navigation + roles + permissions in one shot, eliminating the silent empty-module regression. Gates between phases verify compile + tests + per-module coverage before advancing. Invoked after `/ba-create-prd` + `/ba-audit-prd` (dev-ready GO, score ≥ 80).

Orchestrates multi-module development across applications by executing the phased plan from /ba-create-plan-development. Reads dev-plan.json, runs a preflight check, then drives wave-by-wave execution: for each wave, launches one /ba-develop subagent per module (parallel within a wave), gates between waves (compile + tests for all modules), and reports unified results.

Fetches up-to-date library, framework, SDK and API documentation via the ctx7 CLI (Upstash Context7). Prefer this over web search whenever the user asks about a library, framework, SDK, API, CLI tool or cloud service — even well-known ones like React, Next.js, Prisma, Express, Tailwind, EF Core — because training data may lag behind recent releases. Keywords: library, framework, docs, documentation, SDK, API, package, npm, nuget, version, changelog, migration guide.

Drives a real Chromium browser from Claude Code and from Bash CLI — navigate pages, click elements, read DOM, take screenshots, run end-to-end checks. The SmartStack Studio uses this skill as the test engine for Phase 5 UI tests. Activate when the user asks to open a URL, click a button, test a web page, verify a rendered layout, reproduce a UI bug, submit a form, or script any browser interaction. Keywords: browser, navigate, click, screenshot, DOM, Chromium, Chrome, webpage, URL, visual test, UI verification, E2E.

EF Core migration workflow — create, squash, rebase-snapshot, apply, list, status. Applies the best practices of the global /efcore agents without MCP or external dependencies. Works against a single-assembly generated app (CoreDbContext + ExtensionsDbContext) or the multi-assembly Studio (StudioDbContext with Sqlite / Postgres / SqlServer migration projects).

GitFlow workflow — routes to colocated CLI commands (skills/gitflow/cli/) for deterministic execution

Verify version alignment between package.json and documentation

Detect and fix template drift between SmartStack.app (source of truth) and CLI templates

SmartStack global conventions — DB schemas, prefixes, namespaces

Launch SmartStack dev environment (backend + frontend + admin credentials)

Automatically generates technical documentation for SmartStack. Use this skill when: - User asks to create/generate documentation - User mentions "document", "documentation", "doc", "ERD", "schema" - User wants to document a module, table, tool, or test - After implementing a feature to generate its documentation Types: user module, developer tools, database ERD, testing tools

SmartStack project initialization via smartstack-studio init

Lightning-fast search to answer specific questions - optimized for speed

Multi-category code review — security, architecture, performance

Validate CLI templates by checking that every imported component, type, and method signature documented in /templates/skills/ actually exists in SmartStack.app (IA-Workflow). Catches the "EntityLookup paradox" class of drift where docs reference things that don't exist in the platform.

Verify that a React page (or the whole generated app) respects the SmartStack theme — zero hardcoded colors — and auto-fix the violations. Thin orchestrator over the ui-polish engine: it does NOT reimplement any audit/fix logic, it runs the deterministic ui-polish CLI and then finishes the residual cases (neutral colors with no token) that the CLI cannot map mechanically.

SmartStack project upgrade via smartstack-studio upgrade

Utility skills for SmartStack CLI development

Validate that a scaffolded feature works end-to-end (compile, test, API smoke test)

Audits a SmartStack project for convention violations — namespace prefixes by Clean Architecture layer, entity patterns (BaseEntity + tenant interfaces + private ctor + factory), and controller routing (NavRoute vs hardcoded Route). Produces a structured JSON report of findings. Use when the user asks to audit, validate or check a project's conformance with SmartStack conventions. Keywords: audit, conventions, conformance, check project, validate structure, namespace, NavRoute, entity compliance.

Cross-stack validation backend .NET / frontend React — 5 coherence checks

Static validation of SmartStack React conventions (5 architecture rules)

Deterministic scanner for a generated SmartStack project. Produces a structured JSON manifest of existing entities, migrations, seed providers, controllers, React pages, and extension registries. Consumed by each phase of ba-develop so the Claude subagent can distinguish "already implemented" from "needs to be created" before writing any file. Zero LLM — regex-based scan, runs under 2 seconds on a normal app.

SmartStack readiness report — score /100, aggregation roslyn + eslint + cross-validate

SmartStack C# static analysis — 10 rules (SS001-SS010) per layer