skaile-ai

Browser automation CLI for AI agents. Use when the user needs to interact with websites, including navigating pages, filling forms, clicking buttons, taking screenshots, extracting data, testing web apps, or automating any browser task. Triggers include requests to "open a website", "fill out a form", "click a button", "take a screenshot", "scrape data from a page", "test this web app", "login to a site", "automate browser actions", or any task requiring programmatic web interaction.

Explore a running web app like a user and report its perceived objects, tasks, navigation and visual clarity with an annotated screenshot gallery. Use for 'explore my app', 'how clear is my app', 'UX audit of <url>', or re-running against a previous app-explore report.

Use when the project needs a schema before or while features are specified — derives entities, relationships and enums from whatever exists (glossary, journeys, features, findings, the brief), cites a glossary term for every entity, compares the consequences of the expensive modelling choices with the user, and writes the stack-neutral model with its seed scenarios. Triggers on 'data model', 'design the schema', 'what entities do we need', 'seed data'.

Use when the stack is chosen and the features need more than the stack ships with — records the custom modules, protocols and external integrations this project adds, and stops there. Triggers on 'architecture', 'system design', 'do we need a websocket', 'which modules', 'how does this talk to Stripe'.

Use when a project has no technology decided — scans the stack templates on disk, asks what the project actually constrains, and records the winner as the one id every later skill resolves. Triggers on 'tech stack', 'what should we build this with', 'pick a framework', 'which template'.

[skaile-development] Monorepo-aware code quality audit for the skaile-dev codebase. Verifies build (lint + typecheck + build) and tests pass, then dispatches three parallel sub-agents for logic, security, and UI/UX findings. Three scopes: diff (staged or last-commit), package (one package deep), full (whole monorepo). Produces _devlog/reports/audit-<date>.json. Use before opening a PR or cutting a release.

Autonomous multi-agent skill for writing professional medical textbooks in child and adolescent psychiatry. Simulates a 5-agent team (Architect, Researcher, Pedagogue, Writer, Critic) to produce evidence-based, guideline-grounded content using a layered file architecture. Concept, research, scaffolds, and prose are stored in separate files. Triggers: "Write a book about...", "Start a book...", "/start_book", "/plan_chapter", "/write_chapter".

Use when implementation work needs somewhere to live or somewhere to go — opens the build branch and optional worktree before the first slice, and merges, PRs, keeps or discards it after the last. Triggers on 'start implementing', 'set up the branch', 'finish the branch', 'merge the work'.

Use when the data model is settled and the app needs a real database — translates the model into the stack's schema, migrates it, and generates one runnable seed script per scenario. Triggers on 'migrate', 'generate the schema', 'seed the database', 'set up the data layer'.

Use when a planned vertical slice is ready to build — implements it test-first, reviews it against its spec, then commits it and freezes its dossier — or when a frozen slice's outstanding manual check has been run. Triggers on 'build this slice', 'implement the next slice', 'land it', 'I tested it on the phone'.

Use when a frozen feature spec needs breaking into buildable work — cuts the feature into vertical slices, gives each its blocking edges, and writes one slice dossier per slice. Triggers on 'plan this feature', 'break it into slices', 'what do we build first'.

Use when the stack is chosen and no project exists yet — runs the template's scaffold recipe, then themes it, wires auth and builds the app shell, leaving a running app to build features into. Triggers on 'scaffold', 'bootstrap the project', 'set up the repo', 'create the app'.

Compiles MUST/NEVER/CHECKLIST rules from skaile-development SKILL.md files into fast, deterministic Python validators. Generates a validator.py alongside each SKILL.md. Replaces slow LLM-based validation with sub-second structural checks. Run after editing any skill in ai-assets/skaile-development/skills/.

[skaile-development] Scaffold a new dynamic web component for the Agent App Protocol. Generates COMPONENT.md, web component JS, agent-usage.md, and test harness in the components directory.

Use when a concept has no _concept/brief.md yet, or the user wants to redefine one. Writes the pitch (with its comparables), the goals — the two root files everything downstream reads — and the first feature ideas in the roster. Triggers on 'I have an app idea', 'new project', 'start from scratch', 'redo the brief'.

Use when the product's words are not pinned yet, when another skill has appended proposed terms, or when a concept has no term. Derives the domain vocabulary and its light ontology from what exists, settles the gaps with the user, and writes the glossary every journey, feature, screen, model and test then names things from — in `_concept/glossary.md`, with the definitions in the project's own `CONTEXT.md` when it keeps one. Triggers on 'pin the vocabulary', 'what do we call this', 'write the glossary', 'we use two words for the same thing'.

Use at the start of a project to capture what the pipeline needs and the user already knows — technology preferences, an existing brand, the material they are bringing with them. Also when they say 'I have existing docs', 'use these files', or an answer needs someone who is not in the room. Triggers on 'onboard', 'set up the project', 'ingest my seeds'.

Use when a decision needs grounding in something other than the room's opinion — the domain, the competitors, the audience, or the visual references screens will be designed against; run it once for the project and again beside any step that needs more. Triggers on 'research this', 'what do competitors do', 'find inspiration', 'who are the users really'.

Use when the code already holds a fact the concept needs, or a repository exists and the concept has to be extracted from it rather than designed. Reads the routes, screens, schema, stack, brand, interaction surfaces and docs of the requested scope, and writes what the code actually says as graded, freshness-stamped findings the owning skills seed from. Triggers on 'reverse engineer this project', 'extract the concept from this codebase', 'document this existing app', 're-read the screens from the code'.

Create, customize, batch-produce, or rebuild Skaile presentations as self-contained HTML and PDF with the installed @skaile/decks runtime. Use for pitch decks, consulting reports, reusable slide libraries, storyline-to-slide production, and edits to existing decks artifacts.

Integrated deep research skill that collects documents from multiple sources, stores them in organized folders, and synthesizes findings into a comprehensive research report with citations.

Use when the project has no visual identity yet, or the user wants to change it. Discovers a direction in plain language, extracts from reference sites, and writes the palette, tokens and brandbook; a brief sharpens it and is not required. Triggers on 'brand', 'colors', 'fonts', 'design tokens', 'make it look good'.

Maintains the human-readable _devlog of the standalone skaile repo a change landed in (workspaces: packages/workspaces/_devlog/). Writes short plain-language entry files to _devlog/entries/ after every meaningful change. Generates detailed reports in _devlog/reports/ when architectural concepts, shared contracts, or core patterns change. Run after completing any implementation work.

Use when writing new documentation, updating stale docs, auditing for gaps, or checking documentation status in the skaile-dev monorepo. Covers all five doc tiers: README.md, CLAUDE.md, Starlight docs, DOMAIN.md/SKILL.md, and _devlog.

Run, fix, or extend the Skaile platform e2e suite. Three modes: `run` executes the existing suite with pre-flight checks (stale-service guard for post-pull stale bundles, stale-deps guard for lockfile drift, seed sync, proxy slot health), failure-mode diagnosis, and auto-recovery (kill stale skaile-serve subprocesses, sync seed data, restart stuck proxy slots); `fix` triages each failing test as a stale test (the product changed on purpose) vs a real regression (the product broke), then repairs stale tests (rewrite to the new shape / delete a removed feature / skip with a reason) while STOPPING and escalating regressions to the human — never weakening an assertion to force green; `add` analyzes a git diff, proposes a test plan, waits for explicit user approval, lives-inspects the UI via chrome-devtools MCP, then writes new specs against the existing harness in the platform repo's `e2e/` directory. Use when the user says "run e2e tests", "fix the failing e2e tests", "the e2e suite is red", "add e2e coverage for <feature>", "write e2e tests for my PR", or similar.

Use when an entity's lifecycle has enough states that prose stops being precise about it. Writes the state machines and rules the feature specs and the screens are built against. Triggers on 'state machine', 'behavioral rules', 'formalize the lifecycle', 'what states can this be in'.

Use when the app's interaction rules are not written down yet — navigation model, where information lives, one editor per object, inline vs dialog vs page, information tiers, saving, messages, popups, buttons, search and command palette — or when a code check has proposed changes to them. Adopts the rulebook's defaults with the user, decides what remains in batches and writes APP-DESIGN.md. Triggers on 'write the app design', 'APP-DESIGN.md', 'when do we use a modal', 'UI rules for this app', 'interaction decisions'.

Use when nothing has mapped what users actually do yet. Defines the personas and the staged story map that features are derived from; a brief or the code's routes ground it, and the user's description is enough. Triggers on 'map the journeys', 'user stories', 'what do users do', 'story map'.

Use when one screen needs specifying on its own — a screen already built in the code, a screen a feature needs, or a layout to try before anything is specified. Derives it from the findings or asks, picks the floorplan, posture and density, binds regions, records tier overrides and can show the layout early as a Storybook story. Triggers on 'describe this screen', 'spec the inbox screen', 'which layout fits this', 'show me this screen', 'try two layouts'.

Use when the app needs its frame — the shell frame, the navigation model it realises, the one list of destinations, and the layout patterns every screen reuses. Works with or without features and screens, from the code's own routes when they exist. Triggers on 'app shell', 'navigation structure', 'sidebar or top bar', 'what does the layout look like', 'design the frame'.

[skaile-development] Evaluates resolved questions about the skaile-dev monorepo for FAQ-worthiness and curates entries. Broadened to all monorepo packages.

Git operations for the standalone skaile repos (platform, workspaces, ai-assets, store, brand, …). Five modes: commit (structured commit messages), branch (create/switch feature branches), worktree (parallel work in isolated checkouts), pr (open a pull request), finish (merge/PR/keep/discard branch). The former sync and deploy modes served the retired skaile-dev shell and now stop with a pointer.

The morning startup ritual for skaile-dev — opens with a cheeky "what did Peter do last night" investigation of the repo state, syncs the shell repo + submodules (reattaching any that landed detached at origin/main), reinstalls workspace deps, and builds the platform backend so frontend + backend are ready to start. Does NOT launch dev servers — Peter starts those himself. Use when Peter says "good morning", "/good-morning", "let's start the day", "fire up the platform", "boot me up", or any other morning kick-off phrase.

Monorepo-aware implementation orchestrator for the skaile-dev codebase. Reads the affected package CLAUDE.md files, identifies the tech stack, routes to the right prog-experts, produces a plan, executes with supervised dispatch, then triggers test, doc, and devlog on completion. Use for any non-trivial change to the skaile-dev monorepo.

[skaile-development] The bar a ticket must clear to exist: six impact questions (user harm, money, stability, security, team drag, significant benefit), each answered with evidence. Use before filing an issue an agent found on its own (a ship follow-up, a review leftover, an audit finding), when triaging incoming issues, or when sweeping an existing backlog for tickets that can be closed. Returns KEEP / CLOSE / ASK per ticket with the evidence, and a ready-to-post close comment.

[skaile-development] Debug a recently failed Skaile deployment on Jenkins. Defaults to the `skaile_platform` job; pass `target=store` to debug the `skaile_store` job instead. Reads the job over the local SSH tunnel (http://localhost:8090, anonymous read), finds the relevant build (last failed by default, or current/explicit), extracts the failure region from the console log, cross-references recent commits in skaile-dev around the build timestamp, and reports a structured summary with a fix hypothesis. Use when the user says "why did the deploy fail", "debug the jenkins failure", "what broke on jenkins", "the platform deploy is red", "the store deploy is red", "check the last platform-deploy", or otherwise asks about a Jenkins deployment failure.

Cleanly kills the Skaile platform backend and every process in its spawn chain (port 3001 listener, nest start --watch, dotenvx, bun run dev, sh wrappers). Use when the user says "kill the backend", "stop the backend", "free port 3001", "kill bun run dev", "clean up stray backend processes", or wants a clean slate before restarting `bun run dev` in `platform/backend`.

Use when you need to extract metadata (title, authors, abstract) and references from scientific PDF papers or book chapters.

Use when you need to create a podcast script from the output of the knowledge-paper-research skill.

Given a scientific paper (PDF or Markdown), run a full structured-knowledge extraction and web-research pipeline. Produces one metadata file next to the paper and a dedicated <stem>_research/ folder containing four thematic research files plus one per-author profile file (prefixed author_). Use whenever you need to deeply understand a paper, prepare a research briefing, or enrich a paper's content with external context.

Use when you need to generate long form podcast content from documents using a sophisticated multi-agent orchestration process.

[skaile-development] Distill a git diff into a 'reading diff' for a human: a judgment-call header plus an abridged diff whose every line is verbatim source - mechanical noise (renames, lockfiles, generated files, formatting, import churn) collapsed or dropped. Comprehension, not critique - it does not hunt defects. Use when the user wants to understand a diff rather than review it: before approving a merge, catching up on a branch, reading agent-written code, or when the ship skill offers a reading diff at its final merge question. Concept and rubric from boldsoftware/meat, reimplemented as a prompt - no binary, no extra API key.

Use when you need to migrate a legacy skaile.yaml (schema 4.x and earlier, using `repositories:` or `ai_resources:`) into the new canonical-identity shape (`sources:` + `stores:` + canonical dep refs `kind:@<publisher>/name[#pin]`). Triggers: 'migrate skaile.yaml', 'convert manifest', 'schema 4.x migration', 'update to canonical-identity', 'fix repositories: error', 'fix ai_resources: error', '@skaile to @skaile-ai rebrand'.

Use when stakeholder notes left on the Storybook mockup need to land in the concept, or when the user says 'work through the feedback', 'apply the annotations', 'what did the reviewers say'. Routes each open note to the spec, data-model entity or glossary term it belongs in, authors a reviewable diff for it, and — after you approve the review file — applies the approved diffs in one commit and closes the notes.

Use when a screen, an entity editor or a journey should be seen and critiqued as a running mockup, or when the user says 'prototype this screen', 'build the storybook', 'click-dummy', 'try the editor for this entity'. Grows one Vue Storybook package layer by layer: floorplans, screens, entity editors, the whole app, journeys, and a generated page per feature.

Extract VBA source code (.bas / .cls modules, forms, reports) from a Microsoft Access database (.accdb / .mdb) WITHOUT MS Access installed. Use when asked to extract, dump, recover, or read VBA / macros / module code from an Access database, or when olevba fails with 'not a supported file type' on an .accdb. Handles modern ACE12 'Standard ACE DB' files that olevba and mdbtools cannot decompress.

Team notifications and messaging for skaile-dev. Supports free-form Mattermost messages plus structured templates for plans, breaking changes, releases, and devlog summaries.

Use when _concept/ needs a health check, its cross-references have drifted, or you want to know whether every feature is actually built and shipped. Produces the review verdict and a build-coverage matrix read from the trace, each finding naming the skill that fixes it. Triggers on 'audit the concept', 'check for issues', 'fix the links', 'is every feature done', 'what code belongs to no feature'.

[skaile-development] Use when creating, building, modifying, or extending a PostXL-generated app — including scaffolding a brand-new one into an empty repo with `pxl create-project`. Activates when you see `postxl-schema.json`, `postxl-lock.json`, `generate.ts`, `skaile.preview.json`, or `// @custom-start` markers; when the user mentions PostXL, PXL, `pxl`, regenerate, eject, custom block, or schema drift; when a user asks to build a new full-stack TypeScript app on the PostXL stack (NestJS + Prisma + tRPC + React 19 + Vite); or when a regeneration produced a confusing diff or merge conflict. Also covers the skaile-dev projects `platform/backend`, `platform/frontend`, and `store/backend`.

Use when you need to analyze a user request and find the appropriate prog-expert-* skill from the programming-* directories (e.g. programming-js, programming-python), or when you need to store new implementation knowledge and need to know which expert should learn it.

Use when you need to set up, develop, or integrate Directus into your project, especially with Docker and Nuxt 3. Triggers include "setup directus with docker", "configure directus local development", "generate directus types", "integrate directus with nuxt", or "authenticate with directus sdk".

Use when you need to create, configure, or manage GitAgent-compatible agent definitions (agent.yaml, SOUL.md, RULES.md, SKILL.md). Expert-level programming and pattern management for the GitAgent open standard (spec v0.1.0).

Use when you need to create, edit, or debug Marimo reactive Python notebooks, including cell structure, reactivity rules, output display, and the Lint-Export-Assert test protocol. Expert-level programming and pattern management.

Use when you need to expert-level nuxt development. Expert-level programming and pattern management.

Use when you need to work with omp (pi-coding-agent), including RPC mode integration, skill authoring, extension development, agent embedding, and CLI configuration. Expert-level programming and pattern management.

Use when you need to use when you need to implement advanced primevue 4 features in nuxt 3, including design tokens, forms, and custom theming.. Expert-level programming and pattern management.

Use when you need to implement pydantic-ai Agent API patterns including structured outputs with result_type, message history, OpenAI/Gemini model backends, async streaming with run_stream(), and multi-provider integration. Expert-level programming and pattern management.

Use when you need to implement Python 3.12+ patterns, uv workspace monorepo management, async Python, decorator patterns, pytest/mock testing, ruff/mypy configuration, Rich CLI output, pydantic-settings config, and Protocol-based interface design. Expert-level programming and pattern management.

Use when you need to implement shadcn-vue (shadcn-nuxt) in Nuxt 3/4 — component registry via components.json, Tailwind CSS v4 with @tailwindcss/vite, class-variance-authority, tailwind-merge, and auto-imported shadcn components.

Use when you need to use when you need to implement advanced tiptap editors in nuxt 3, including collaboration, custom node views, and context menus.. Expert-level programming and pattern management.

Use when you need to implement TTS (text-to-speech) or STT (speech-to-text) integrations in Nuxt 3/Nitro applications, including Deepgram streaming STT via WebSocket, ElevenLabs TTS, browser MediaRecorder, and audio settings management. Expert-level programming and pattern management.

Use when you need to implement a typst template from an image or pdf reference iteratively. Expert-level programming and pattern management.

Use when you need to implement UnaUI (@una-ui/nuxt) in Nuxt 3/4 — N* component usage, color tokens, slot patterns, UnoCSS-driven theming, and UnaUI module configuration.

Use when you need to implement or configure UnoCSS in Nuxt 3/4 projects — presets (wind4, icons, attributify, typography), uno.config.ts theming, dark mode, safelist, layers, and UnoCSS module integration.

Use when you need to implement VueUse composables in Nuxt 3, including auto-import configuration, composable selection, conflict handling with Nuxt built-ins, and reactive browser/state/DOM utilities. Expert-level programming and pattern management.

Create, review, or update a design spec / proposal for new features, architectural changes, or cross-package work in the skaile-dev monorepo. Use when work is too complex to jump straight into code — the spec captures the problem, design, alternatives, and approval status before implementation begins.

Use when an app is built or adopted and you suspect its design, not its conformance, is what hurts users — scans the code against the rulebook, the glossary and APP-DESIGN.md for shallow screens, overloaded concepts, hidden modes, undeclared representations and tier violations, reports evidenced candidates, then grills the one you pick. Triggers on 'what is wrong with this design', 'find design problems', 'which screens should merge', 'improve the UX of this app', 'design review of the code'.

Use when the app runs and its journeys need proving end to end in a real browser — drives every story from stories.yaml with agent-browser, screenshots each step, checks the database behind it, and writes each journey's verdict into the acceptance-criteria ledger. Triggers on 'test the app', 'e2e tests', 'browser testing', 'walk the journeys'.

Use when an app's code exists — checks it against the interaction decisions in APP-DESIGN.md entry by entry and type by type (against the rulebook's invariants alone when none is written), counts violations and exemplars per rule, and writes the ordered changes that close them. Triggers on 'check the app against APP-DESIGN.md', 'does the UI follow our patterns', 'interaction review', 'where do we still break the rules'.

Use as the last gate before a release — walks the whole running application against the brief and goals it started from and grades it on seven axes, then writes the release verdict. Triggers on 'is this ready to release', 'grade the app', 'final gate', 'release review'.

Use when a feature's slices are frozen and its code needs an adversarial review before it ships — resolves the fixed point from the trace and the spec from the feature file, runs `code-review`, and adds the security, accessibility and acceptance-criteria axes. Triggers on 'review this feature', 'code review the login feature', 'is this ready to ship'.

Use when work is starting against an existing codebase and its conventions have not been written down — scans the code for the patterns it already follows and records them as standards the build skills read. Triggers on 'discover standards', 'what conventions does this codebase use', 'analyse the codebase'.

Use when built features need a test suite that traces back to their specs — learns the project's test conventions from its existing tests, then writes unit tests and, where there is a data layer, integration tests. Triggers on 'generate tests', 'add test coverage', 'write integration tests'.

[skaile-development] Umbrella quality-gate orchestrator for the skaile-dev monorepo. Runs typecheck → test (with coverage + ratchet when the mode requires it) → audit → doc-audit → ready in sequence, early-outing on the first hard failure. Produces a consolidated health snapshot that contributors look at before opening a PR and release uses as its pre-flight check. Supports quick (diff-scoped), package (one package deep), and full (whole monorepo, mirrors test-full.yml CI lane) modes.

Pre-release readiness gate for the skaile-dev monorepo. Verifies every package has README + CLAUDE.md with required sections, tests passing, build clean, typecheck clean, CHANGELOG present, and Starlight registration for packages with docs/. Produces a blocker/warning table and exits non-zero on any hard failure. Called by release as Phase 0.

Changelog management, semantic versioning, and git tagging for skaile-dev domains and packages. Three modes: status (show current version + unreleased changes), bump (update version + CHANGELOG.md), tag (create annotated git tag).

Write or rewrite technical prose in ASD-STE100 Simplified Technical English: one statement per sentence, active voice, fixed terms. Use for report prose, 'STE', 'simplified English', 'make this unambiguous'.

Quantities as `bars` or Vega-Lite `vega` charts with tooltips, selections and cross-filter. Use for 'how much', 'distribution', 'over time', 'compare counts'.

Dependency `map` canvases, `board` moodboards (screens today vs. proposed, changes marked) `concepts` figures (UI variants per state with their linked terms), `mock` dialogs and mermaid notations (sequence, class, ER, C4, gantt, mindmap, sankey, railroad) with the notation-choice table. Use for 'what depends on what', 'who calls whom in which order', 'moodboard', 'before/after of screens', 'which UI variant', 'how do these terms relate', 'draw this as a diagram'.

Capture how code or a pipeline works from the source (trigger, steps, stores, error paths, file:line evidence) and draw levelled DFD `flow`, `lineage` and `states` diagrams. Use for 'how does X work', 'what becomes what', 'which states'.

Write report prose people read front to back: an argued answer (claim, reason, consequence), the reader's words before code names, few links, lists only after a lead sentence, examples and contrasts where they explain. Use for report prose, 'make this readable', 'too technical', 'rewrite for people'.

Dump collections, detect keys/relations/enums with detect.py, and render entities as badge-filtered trees and interactive sortable/searchable tables. Use for inventories, 'which X exist', 'how many', data sheets.

Chaptered, narrated manim explainer of a report's main concepts with a brand look, embedded as a `video` block with captions and chapters. Use only when the user asks for a video, animation or explainer.

Build one static HTML report read front to back: argued answer first, tables, trees, diagrams and charts as support. Use for 'report', 'overview page', 'data sheet', 'how does X work as a page'. Autopilot by default; 'report interactive: <question>' asks first; a pasted '# Notes on report' block revises it.

[skaile-development] Code review for staged or committed changes in the skaile-dev monorepo. Checks quality, security, performance, scope, and repo-specific rules. Works locally without CI - designed for direct-to-main workflows.

[skaile-development] Cross-session analysis of Claude Code session data for the skaile-dev monorepo. Reads a pre-computed digest (≤10KB) from the Python pipeline, triages improvement opportunities, reads implicated SKILL.md files, and proposes concrete diffs to reduce token waste and improve workflow adherence. Run after ./run.sh in _scripts/session-analysis/.

[skaile-development] Reviews the current Claude Code implementation session for the skaile-dev monorepo: reads the session JSONL to report token usage, cache efficiency, estimated cost, and workflow adherence against the skaile-development skill sequence. Outputs optimization tips and skillset improvement suggestions. Run at the end of any implementation session.

Take one piece of work in one repository from "somebody described it" to a traceable, reviewed, checks-green change whose fate the human decided. Use whenever someone wants something in a repository actually changed rather than explained - however casually they put it. "can you sort it", "can you take it", "can we get X on this", "have a look at #12" and "fix it and push it" are all this skill; the person does not have to mention branches, a pull request, review or merging, and the change can be as small as one constant, one string of copy or one dependency bump. Also use when handed an issue number or link to build, or an already-open pull request from this kind of work to carry the rest of the way. It runs the whole cycle in one flow - files the tracker issue, branches in an isolated worktree, implements, gets the diff reviewed, opens the PR, drives CI and review feedback to green - then recaps in plain language and asks once whether to squash-merge and clean up. Do not use for questions, diagnosis or code explanation, for reviewing someone else's existing code, for plans or design proposals, for filing an issue when implementation is explicitly deferred, for throwaway local experiments, or for work spanning several repositories.

[skaile-development] Use when reasoning about whether and how to build an app idea on the Skaile/PostXL stack -- choosing between platform skills+flows, forge integration tiers, the agent runtime, or PostXL alone. Loads the four context packs (agent framework, ecosystem, platform, PostXL) on demand and routes the question to the relevant doc(s). Trigger when the user asks 'should we build X with Skaile?', 'where in the stack does this fit?', 'platform or standalone app?', 'PostXL or just NestJS?', or any architectural orientation question across the Skaile/PostXL surface.

Use when the user names something they want — an artifact, a screen, a question, a request — and the skill that produces it or what it needs is unclear, when a project has no recorded scope or expectations, or to walk the concept top-down (frame → look → data → features) before anything is built. Triggers on 'which skill', 'where do I start', 'how do we work together', 'walk me through the app', 'what is decided', 'continue the concept', 'describe this screen', 'I have a bug report', 'a feature was requested'.

Use when integrating LLM agent sidecars (omp RPC) into a web frontend. Covers the Typed Action Protocol: SkillAction/ConsumerResponse bidirectional events, skill state machine, adapter layer, structured input/approval flows, API key resolution, and default model selection. Expert-level programming and pattern management.

Use when you need to design, build, or refine LLM agent skill systems with pipeline orchestration, artifact-based gates, cross-references, profiles, and UI integration. Expert-level skill architecture and pattern management.

Use when one feature needs its permanent spec — compares it with the features and ideas that exist, grills the user, draws the in/out line, then writes the feature spec and adds its roster row. Triggers on 'spec this feature', 'what features do we need', 'group the features', 'lock down acceptance criteria', 'what is in vs out'.

Cross-document reference repair across the skaile-dev monorepo. Scans README ↔ CLAUDE.md ↔ docs/<pkg>/ ↔ DOMAIN.md ↔ monorepo CLAUDE.md and finds broken links, missing back-references, orphan Starlight pages, stale _sources frontmatter, and drift between the monorepo domain table and actual ai-assets/*/DOMAIN.md files. Shows a complete diff of proposed changes before applying — non-destructive.

[skaile-development] Set up and generate end-to-end tests for skaile-dev packages: forge apps, platform/frontend, and the agent-framework CLI. Scaffolds Playwright for web apps (forge + platform) including config, global setup/teardown, sandbox, and fixtures. For CLI packages, generates shell-based end-to-end tests that invoke the bin and assert stdout/artifacts. Verifies tests run against a real dev server or real process.

Set up and generate integration tests for any skaile-dev package. Covers API routes, DB operations, and cross-module flows. Knows the storage backends: SQLite + drizzle for forge apps, PostgreSQL + Prisma for platform/backend, temp-dir state for agent-framework. Scaffolds test DB isolation (in-memory SQLite / ephemeral test DB / temp workspaces), auth helpers, seed fixtures, then generates tests. Verifies tests run.

Generates a per-package test plan for any skaile-dev package. Reads CLAUDE.md (architecture, public API), the source tree, and existing tests; produces <package>/TEST_PLAN.md listing untested units, coverage gaps, integration seams, and recommended scenarios per layer (unit/integration/e2e). Used as the input for test-unit, test-integration, and test-e2e.

Set up and generate unit tests for any skaile-dev package (forge apps, agent-framework libraries, platform frontend/backend). Reads TEST_PLAN.md when present, otherwise discovers testable units from source. Scaffolds missing test infra (vitest.config.ts, test harness), then generates one test file per module with test cases mapped to CLAUDE.md Architecture. Verifies tests run before completing.

Test construction and execution for the standalone skaile repos. Two modes: 'run' executes the test suite for one or more packages and reports results; 'construct' generates new tests for recently implemented code. Knows each repo's test stack and runs it from that repo's root: Vitest in workspaces (Biome repo; coverage via @vitest/coverage-istanbul under Bun, ratcheted by packages/workspaces/_scripts/check-coverage-ratchet.ts), Jest (platform backend), Vitest (platform frontend), Playwright (platform e2e), plus the forge apps' own scoped Vitest and Playwright runs.

Use when you need to read the contents of an office document fast - Word, PowerPoint, Excel, OpenDocument, RTF, EPUB, CSV, or a digital-native PDF - and convert it to Markdown for orientation, summarization, or data extraction. Pinned Rust CLI (`@firecrawl/anydoc@0.2.4`), no API key, no OCR, no ML models. Read-only: it cannot edit a document, and it drops formulas and cell addresses, so it is not a substitute for mcp:excel or mcp:ppt when the task is to modify a file.

Use when you need to search for programming library documentation or fetch up-to-date code examples via the Context7 REST API. Provides direct CLI access to Context7 without requiring the MCP server — search libraries by name and retrieve markdown documentation with code examples. Use when the user asks about library APIs, how to use a package, or needs current documentation for a specific library version.

Opt-in only, not for default use. Use when a project has deliberately installed a pinned, offline docling (>= 2.132.0) and you need OCR, a vision model or speech transcription on a local file. For reading ordinary office documents and digital PDFs, use use-anydoc instead.

Use when you need to convert markdown speaker dialogue and text into audio using the ElevenLabs API. Includes support for single voice TTS and multi-voice conversational dialogues.

Use when you need to search the web or find code examples using Exa's AI-powered search. Queries Exa's public MCP endpoint with JSON-RPC — no API key required for basic web search and code search.

Use when you need to generate an image from a text prompt - posters, logos, illustrations, photoreal scenes, images with legible text. Calls the Skaile platform capability platform.generate_image, which uses the organization's configured image provider (Ideogram, Recraft, FLUX or another) and saves the result into the session workspace. Needs no API key: the platform holds the provider and its key.

Use when you need to interact with MCP (Model Context Protocol) servers, OpenAPI specs, or GraphQL endpoints via CLI. Converts API schemas into token-efficient CLI commands at runtime without code generation.

Search, read, and manage Outline wiki documents. Use when: (1) searching wiki for documentation, (2) reading wiki pages or articles, (3) listing wiki collections or documents, (4) creating or updating wiki content, (5) exporting documents as markdown. Works with any Outline wiki instance (self-hosted or cloud).

Search, read, and manage Outline wiki documents. Use when: (1) searching wiki for documentation, (2) reading wiki pages or articles, (3) listing wiki collections or documents, (4) creating or updating wiki content, (5) exporting documents as markdown. Works with any Outline wiki instance (self-hosted or cloud).

Use when you need to research topics or answer complex questions by querying Perplexity via the OpenRouter API.

Build slide decks using Reveal.js in Skaile's brand design. Produces an index.html + skaile-theme.css that renders as a dark-themed, gradient-accented presentation with Plus Jakarta Sans / Inter / JetBrains Mono typography.

Use when you need to search the internet for current information, research topics, find news, or look up web content. Queries a local SearXNG instance with Google as the primary search engine and returns clean, structured markdown results.

Use when discovering, researching, or installing agent skills from the open skills.sh ecosystem. Handles discovery via npx skills find, quality verification, and workspace integration via skaile source add / skaile install.

Build slide decks using Slidev (sli.dev) in Skaile's brand design. Produces a slides.md + style.css that renders as a dark-themed, gradient-accented presentation with Plus Jakarta Sans / Inter / JetBrains Mono typography.

Designs and implements small, focused, agent-friendly CLI tools using uv and Typer. Use when you need to wrap a capability as a command-line interface instead of an MCP server, so that LLM agents can invoke it via shell commands.

Visual verification of Skaile platform UI changes using browser automation. After implementing a UI feature, run this skill to systematically check that pages render correctly, navigation works, and key interactive elements are present. Uses agent-browser CLI and chrome-devtools MCP tools.

Create or edit an organization's Microsoft Word (.docx) documents with the Word MCP, starting from the organization's own template when one exists and from the neutral blank baseline otherwise. Use for reports, letters, memos, minutes and other Word deliverables that must keep Named styles, numbering, headers, footers and fields intact; do not use for read-only summaries or non-.docx files.

Client-specific example; for generic Word documents use word-document. Create or edit organization-standard Microsoft Word (.docx) documents with a bundled house template and writing guide. Use when a deliverable must preserve the template's branding, heading numbering, headers, footers, bullets, or Word-native structure; do not use for unrelated Word documents or read-only summaries.