Dev10x

Synthesize arguments from architect agents into ranked ADR options. Fact-checks claims against the actual codebase. Used by Dev10x:adr-evaluate skill during the synthesis phase. Triggers: invoked by Dev10x:adr-evaluate skill only

Evaluate API design decisions — REST, GraphQL, gRPC patterns, schema design, real-time strategies, and API layer compliance. Used by the adr-evaluate skill for API-related ADRs. Triggers: invoked by adr-evaluate skill for API design ADRs

Evaluate database architecture decisions — schema design, indexing, multi-tenant strategies, JSONB patterns, migration safety, and query optimization. Used by adr-evaluate for data ADRs. Triggers: invoked by adr-evaluate skill for database architecture ADRs

Evaluate domain modeling decisions using DDD principles, Software Archetypes, and Clean Architecture patterns. Used by adr-evaluate for domain modeling ADRs. Triggers: invoked by adr-evaluate skill for domain modeling ADRs

Evaluate frontend architecture decisions — component patterns, state management, SSR strategies, testing approaches, and design system patterns. Used by adr-evaluate for frontend ADRs. Triggers: invoked by adr-evaluate skill for frontend architecture ADRs

Evaluate infrastructure decisions — deployment strategies, CI/CD pipeline design, Docker patterns, observability, and environment management. Used by adr-evaluate for infrastructure ADRs. Triggers: invoked by adr-evaluate skill for infrastructure ADRs

Use this agent when you need to evaluate software architecture, identify design issues, or plan new component designs. Covers Clean Architecture, DDD, SOLID principles, and enterprise patterns. Triggers: "review the architecture", "design a new component", "evaluate this design", "identify tech debt"

Use this agent to review code changes in the current Git branch according to project standards and best practices. Reviews only changed files — not the entire codebase. Triggers: "review my code", "check this before PR", "code review" Do NOT use for: reviewing entire codebases, writing code, fixing issues

Use this agent to investigate Kubernetes infrastructure, troubleshoot deployment issues, analyze observability stacks, check resource states across environments, or find discrepancies between git configs and actual cluster state. Triggers: "check k8s", "why is this pod failing", "compare staging and production", "investigate deployment", "zombie resource"

Use this agent to investigate bugs, errors, performance issues, or unexpected behavior in any project. Performs deep-dive analysis including database forensics, code path tracing, timeline reconstruction, and root cause hypothesis generation. Triggers: "investigate this bug", "why is this failing", "debug this error", "trace the root cause", "performance issue"

Use this agent when you need to audit Claude Code permission settings for security gaps, overly broad allow rules, missing deny rules, unregistered hooks, privilege escalation paths, and script-path leaks in instruction files. This agent performs a comprehensive 7-phase analysis of settings.local.json, settings.json, hook scripts, and instruction files (CLAUDE.md, memory), then produces a severity-categorized report with specific fix proposals. Triggers: "audit permissions", "check allow rules", "are hooks registered?", "harden my settings"

Use this agent to write, review, or improve Python unit tests using pytest. Covers fixture design, mockito stubs, parametrization, and comprehensive coverage patterns. Triggers: "write tests for", "review my tests", "help with fixtures", "test coverage for"

Use this agent to run tests and verify coverage before committing, when creating a PR, or after writing new code. Ensures test suite passes and provides concise summaries. Triggers: "run tests", "check coverage", "verify tests pass", "ready to commit"

Review Celery task definitions for naming, periodic registration, discovery, and data migration safety. Triggers: files matching **/tasks.py, **/celery.py

Review Playwright page objects and pytest-bdd feature files for step deduplication, locator fragility, and fixture alignment. Triggers: files matching **/e2e/**/*.py, **/e2e/**/*.feature

Review frontend files — components, routes, i18n, auth patterns, accessibility, and SSR safety. Triggers: files matching **/*.svelte, **/*.astro, **/*.tsx, **/*.jsx

Review GraphQL schema changes for type safety, backward compatibility, authorization, and Clean Architecture compliance. Triggers: files matching **/api/queries.py, **/api/mutations.py, **/schema.py

Review database migration files for data loss, backward compatibility, lock contention, and tenant scoping. Triggers: files matching **/migrations/*.py

Review signal handlers, event receivers, and repository lookup semantics for correctness, naming, and exception safety. Triggers: files matching **/signals.py, **/handlers.py, **/receivers.py

Detect test flakiness risks: random ID collisions, low-entropy providers, constraint races, and missing branch coverage. Triggers: files matching **/tests/**/*.py

Review test files for pattern compliance, coverage gaps, fixture DRY, mockito teardown safety, and parametrization best practices. Triggers: files matching **/tests/**/*.py

Orchestrate adversarial evaluation of architectural options using domain-specific architect agents and produce ranked ADR drafts. TRIGGER when: evaluating design decisions with multiple competing approaches, running architecture trade-off analysis, or needing structured multi-perspective evaluation. DO NOT TRIGGER when: creating a simple ADR (use Dev10x:adr), or making code changes without architecture impact.

Create Architecture Decision Records (ADRs) following project conventions. Extends the base scope skill with ADR-specific format, numbering, diagram generation, and decision documentation. TRIGGER when: documenting significant architectural decisions, design trade-offs, or technology choices that affect the codebase. DO NOT TRIGGER when: making code changes without architecture impact, or writing commit messages (use Dev10x:git-commit).

Reformulate plain-text questions into structured AskUserQuestion widgets and reinforce the decision-gate convention. Two modes: reformulate recent questions into clickable options, or output a reinforcement nudge when an agent asks plain-text decisions. TRIGGER when: supervisor sees a plain-text decision question that should have been an AskUserQuestion widget, or wants to convert recent prose questions into structured prompts. DO NOT TRIGGER when: agent is already using AskUserQuestion correctly, or the question is purely informational (no decision).

File skill-audit findings as a GitHub issue at the Dev10x plugin repo. Invoked by skill-audit Phase 7 when the user opts in. TRIGGER when: skill-audit Phase 7 completes and user opts to file upstream. DO NOT TRIGGER when: no audit findings exist, or user wants to review findings before filing.

Audit context window utilization — CLAUDE.md files, rules, agent specs, references, and memories. Reports budget compliance, flags oversized files, and suggests pruning actions. TRIGGER when: user wants to optimize context usage, after adding many rules or memories, or when sessions feel sluggish from context bloat. DO NOT TRIGGER when: auditing memory content quality (use Dev10x:memory-maintenance instead).

Safe read-only psql wrapper for Claude Code. Provides db.sh with SQL validation hook so database queries are safe and auditable. Configure databases in databases.yaml with env var or keyring backends. TRIGGER when: executing SQL against configured databases. DO NOT TRIGGER when: planning queries (use Dev10x:db), or working with non-database tasks.

Safe database query planning for Claude Code. When querying any database, ensures schema-first construction and read-only safety so queries are accurate and never modify production data. TRIGGER when: code needs database queries, schema discovery, or SQL construction. DO NOT TRIGGER when: no database interaction needed, or user is writing application code that happens to mention SQL in comments.

Run or continue a DDD Event Storming workshop to explore, model, and stress-test domain architecture. TRIGGER when: user mentions DDD, domain modeling, event storming, bounded contexts, domain events, aggregates, "workshop", "domain session", "stress test the architecture", "apply archetype", "scope the domain", or asks domain exploration questions like "add tax support" or "what breaks if we add goods pricing". Always use before ticket-scope when the feature area is new or crosses bounded context boundaries. DO NOT TRIGGER when: implementing code within a well-understood domain, or scoping a ticket in a known bounded context (use Dev10x:ticket-scope).

EXPERIMENTAL — parallel fanout using worktree-isolated agents. Tests whether Write/Edit constraints from GH-549/PR #584 still apply. Creates one worktree per issue and dispatches background agents with mode: "dontAsk" + isolation: "worktree". TRIGGER when: user explicitly invokes for parallel testing. DO NOT TRIGGER when: production fanout work (use Dev10x:fanout).

Close multiple open loops in parallel — PRs waiting for review, issues ready for implementation, tickets needing attention. Honors dependencies, minimizes conflict risk, auto-advances by default. TRIGGER when: 2+ independent work items need parallel processing (PRs, issues, tickets). DO NOT TRIGGER when: single task or sequential dependency chain (use Dev10x:work-on).

Detect PR context (number, repo, URL, branch) from a URL, PR number, or current branch — so skills like Dev10x:gh-pr-monitor always get the correct target PR even in multi-worktree setups. TRIGGER when: resolving PR context from URL, number, or branch for downstream skills. DO NOT TRIGGER when: PR context is already known and passed explicitly.

Post a rich session bookmark comment on a PR — captures session ID, review thread status, current state, and next steps so the next session can pick up where this one left off. TRIGGER when: pausing or ending session with an open PR that has in-progress work. DO NOT TRIGGER when: no PR exists, or session-wrap-up handles bookmarking automatically.

Create a GitHub pull request for the current branch with issue tracker integration (GitHub Issues, Linear, or JIRA). Sources or generates a JTBD Job Story for the PR description, extracts ticket info from branch name, pushes the branch, creates a draft PR with Job Story, commit list, and issue tracker link, posts summary comment, and opens in browser. TRIGGER when: branch is ready for PR creation, user says "create PR". DO NOT TRIGGER when: PR already exists (use Dev10x:gh-pr-respond or Dev10x:gh-pr-monitor instead), or user just wants to push changes.

Use when merged PRs may have unresolved review threads accumulating as silent tech debt — so unaddressed feedback gets surfaced, grouped by theme, and tracked as issues. TRIGGER when: reviewing merged PRs for accumulated tech debt, or post-merge as part of maintenance workflow DO NOT TRIGGER when: reviewing active draft PRs, or as part of automated PR review (not designed for real-time feedback)

Implement a fix for a validated PR review comment, create a fixup! commit, push, and reply with the commit reference. Creates ONE fixup commit per comment. TRIGGER when: PR review comment has been validated as needing a code fix. DO NOT TRIGGER when: comment is invalid/question (use Dev10x:gh-pr-triage first), or creating standalone fixup without PR context (use Dev10x:git-fixup).

Validate all pre-merge conditions and execute PR merge. Checks unresolved threads, CI status, draft state, mergeability, working copy, fixup commits, and review approval before merging. TRIGGER when: PR is ready to merge and needs pre-merge validation. DO NOT TRIGGER when: PR is still draft, CI is failing, or review comments are unaddressed.

Launch a background agent to monitor PR CI checks and review comments, automatically address issues with fixup commits, and notify team when ready. Use after creating a PR to automate the entire review cycle. TRIGGER when: PR has been created and needs CI/review monitoring. DO NOT TRIGGER when: PR does not exist yet (use Dev10x:gh-pr-create first), or user wants to manually handle review comments.

Request review on a GitHub PR from teams or users. TRIGGER when: PR is ready for review and needs reviewer assignment. DO NOT TRIGGER when: PR is still draft or WIP, or review was already requested.

Validate and respond to PR review comments. Handles single comment (with follow-up offer) or batch mode for all unaddressed comments on a PR/review. Orchestrates Dev10x:gh-pr-triage and Dev10x:gh-pr-fixup. TRIGGER when: PR has review comments that need responses or fixes. DO NOT TRIGGER when: no review comments exist, or user wants to create a new PR (use Dev10x:gh-pr-create).

Review a GitHub pull request and post findings with inline comments. Fetches PR diff, reads changed files, checks for interface impact, applies project review guidelines, and posts a COMMENT review to GitHub. TRIGGER when: reviewing an external PR and posting review comments. DO NOT TRIGGER when: reviewing own branch changes before PR creation (use Dev10x:review), or PR does not exist yet.

Validate a PR review comment against the codebase. If invalid, reply with evidence. Never auto-resolves threads — resolution requires explicit user confirmation. Returns a verdict (VALID, INVALID, QUESTION, OUT_OF_SCOPE) so the caller knows whether a code fix is needed. TRIGGER when: PR review comment needs validation before implementing fix. DO NOT TRIGGER when: comment is clearly valid and needs immediate fix (use Dev10x:gh-pr-fixup directly).

Set up git aliases that reduce permission friction by wrapping $(git merge-base ...) subshells into stable command prefixes. TRIGGER when: SessionStart reports missing aliases, or user hits permission friction from subshell-based git commands. DO NOT TRIGGER when: aliases already configured (check git config).

Split monolithic git commits into atomic, cohesive commits following Clean Architecture principles. Uses interactive rebase to separate changes by feature dependency order (utilities → data → DTOs → refactoring → features → API), ensuring each commit is self-contained, passes tests, and maintains proper cohesion. TRIGGER when: a commit contains mixed concerns that should be separate atomic commits. DO NOT TRIGGER when: commits are already atomic, or grooming history without splitting (use Dev10x:git-groom).

Create a properly formatted git commit following project conventions (gitmoji, ticket reference, 72 char limit). Extracts ticket ID from branch name, prompts for description and solution points, stages changes, and creates the commit. TRIGGER when: creating a git commit with proper formatting. DO NOT TRIGGER when: amending commits, creating fixup! commits (use Dev10x:git-fixup), or splitting commits (use Dev10x:git-commit-split).

Create a fixup! commit for a PR review comment or standalone improvement. Enforces one fixup per comment thread when linked to a review. TRIGGER when: creating a fixup! commit for a review finding or standalone improvement. DO NOT TRIGGER when: creating a regular commit (use Dev10x:git-commit), or implementing PR fixes with push and reply (use Dev10x:gh-pr-fixup).

Restructure, polish, and clean up git commit history in the current branch before merging. Creates atomic, well-organized commits that tell a clear story. TRIGGER when: branch is ready for merge and commit history needs cleanup (squash fixups, reorder, reword). DO NOT TRIGGER when: branch has clean history already, or splitting individual commits (use Dev10x:git-commit-split).

Convert existing git commits into issue tracker tickets with proper branch management and commit message formatting. Automates creating the ticket, branching, cherry-picking, and updating the commit message. TRIGGER when: a commit needs to be retroactively tracked with a ticket, typically for tech debt fixes, bug fixes, or improvements committed without a ticket reference. DO NOT TRIGGER when: commit already has a ticket reference, or creating a new ticket before committing (use Dev10x:ticket-create).

Create git worktrees for clean workspace isolation. Offers two modes: native EnterWorktree (switches CWD in current session) or external worktree (IDE-isolated, requires restarting claude in new dir). TRIGGER when: starting feature work needing isolation, or executing implementation plans with independent tasks. DO NOT TRIGGER when: work can be done on the current branch without isolation, or user explicitly wants to stay in the current worktree.

Use before running git push or git rebase — so force-pushes to protected branches are blocked and non-interactive rebases run unattended without manual editor approval prompts. TRIGGER when: running git push or git rebase operations. DO NOT TRIGGER when: other git operations (commit, status, log, diff) that don't need push/rebase safety.

Root-cause a bug report, question, or unexpected behaviour from a Slack thread — posts a technical reply with GitHub links and creates a Linear ticket when warranted. TRIGGER when: given a Slack URL pointing to a bug report, question, or unexpected behaviour that needs investigation. DO NOT TRIGGER when: no Slack URL provided, issue already root-caused, or user wants to investigate without posting a reply.

Pure JTBD story drafting skill. Gathers context from issue tracker tickets, parent tickets, and PR diffs to craft a situation-driven Job Story with explicit actor and beneficiary. Returns the draft string with no side effects. TRIGGER when: drafting a JTBD Job Story for a ticket, PR, or release. DO NOT TRIGGER when: Job Story already exists on the target, or writing commit messages (use Dev10x:git-commit).

Linear issue tracker operations via MCP tools. Get, create, update issues and list comments. Documentation-only skill — no scripts. TRIGGER when: performing CRUD operations on Linear issues, comments, or statuses. DO NOT TRIGGER when: using GitHub Issues or JIRA (use Dev10x:jira), or creating tickets across trackers (use Dev10x:ticket-create).

Audit project and global memory files for stale patterns, version-pinned paths, contradictory instructions, and anti-patterns that cause skill bypass or permission friction. Reports findings and offers to clean up. TRIGGER when: user wants to audit memory health, after a plugin upgrade, or when agents keep bypassing skills despite memory instructions. DO NOT TRIGGER when: user wants to save or recall a specific memory (use the auto memory system directly).

Guided discovery of Dev10x capabilities for new users. Interactive tour through skill families, git setup, PR pipeline, session management, and customization — adapted to experience level. TRIGGER when: user is new to Dev10x, asks what it can do, or wants a walkthrough of available capabilities. DO NOT TRIGGER when: user already knows what skill to use, or is asking about a specific feature (use that skill directly).

Gather deferred items across all sources — so nothing is missed when starting a session or picking up where you left off. TRIGGER when: starting a session, picking up prior work, or checking for deferred items. DO NOT TRIGGER when: mid-session active work with no need to check deferred items.

Schedule a Slack reminder — so deferred items appear when you are clearing messages, not buried in a file you might not open. TRIGGER when: deferring work that should resurface via Slack notification later. DO NOT TRIGGER when: deferring to code or project storage (use Dev10x:park-todo), or routing to the best destination automatically (use Dev10x:park).

Defer work to code or project-level storage — so items resurface when editing nearby code or starting a new session in the same project, instead of being forgotten. TRIGGER when: deferring work to code comments, TODO.md, or project memory files. DO NOT TRIGGER when: deferring to Slack (use Dev10x:park-remind), or routing to the best destination automatically (use Dev10x:park).

Smart deferral router — saves tasks for later to the right place (PR, ticket, code, Slack, or project TODO) so they are actually rediscovered instead of being forgotten. TRIGGER when: a task should be saved for later instead of done now. DO NOT TRIGGER when: task should be done now, or specifically deferring to code (use Dev10x:park-todo) or Slack (use Dev10x:park-remind).

Reconcile persisted plan file with in-session task list. Detects divergences, recreates missing tasks, and updates plan context. TRIGGER when: session resumed after compaction and task list is empty or out of sync with the plan file. DO NOT TRIGGER when: no plan file exists or task list is already in sync with the current session work.

Review user playbook overrides against current defaults to detect drift. Identifies new steps, improved prompts, updated fragments, and structural changes in defaults that overrides have missed. Presents findings with recommendations and delegates edits to Dev10x:playbook. TRIGGER when: user wants to check if their playbook overrides are up to date, after a plugin upgrade, or when defaults have changed. DO NOT TRIGGER when: user wants to view or edit a specific play (use Dev10x:playbook instead).

View and customize playbooks (step-by-step procedures) for any orchestration skill. List playbook-powered skills, inspect plays, edit steps through a guided flow, or reset to defaults. TRIGGER when: user wants to view, edit, or customize playbook workflows for skills. DO NOT TRIGGER when: executing a playbook-powered skill (handled automatically by Dev10x:work-on or other orchestrators).

Run Playwright Python scripts against ExampleCorp staging safely. Use when writing or executing a Playwright automation script for self-QA or browser testing on staging-app.example.com. Handles CF Access headers, credential injection, syntax validation before execution, and uv run wrapping — so secrets are never hardcoded in scripts. TRIGGER when: running browser automation against ExampleCorp staging. DO NOT TRIGGER when: testing non-ExampleCorp sites, running unit tests, or writing Playwright scripts for other projects.

Comprehensive project-level architecture audit. Catalogs design patterns from multiple sources, stress-tests domain models, maps JTBD from PR history against test coverage, and produces a prioritized improvement backlog. TRIGGER when: user requests architecture audit, project health check, pattern catalog mapping, or comprehensive quality review. DO NOT TRIGGER when: reviewing a single branch (use Dev10x:review), scoping a single ticket (use Dev10x:ticket-scope), or running a DDD workshop (use Dev10x:ddd-workshop).

Scope a multi-ticket project with milestones, blocking relationships, and tracker integration. Accepts a parent ticket URL/ID or free-text description and creates the full project structure in Linear, JIRA, or GitHub Issues. TRIGGER when: scoping a multi-ticket project with milestones and blocking relationships. DO NOT TRIGGER when: scoping a single ticket (use Dev10x:ticket-scope), or creating individual tickets (use Dev10x:ticket-create).

Fix a flaky Python test end-to-end — investigate, reproduce, patch the root cause, and ship the fix with a tracker ticket, branch, and PR. Orchestrates Dev10x ticket, branch, commit, and PR skills so fixes follow project conventions without per-step coaching. TRIGGER when: user reports a flaky pytest test, a test is marked `@pytest.mark.flaky`, or a pytest case fails intermittently in CI. DO NOT TRIGGER when: test failure is deterministic, a non-pytest framework is in use, or the fix is already committed.

Run pytest with coverage enforcement. Verifies test suite passes with 100% coverage for new code. Reports pass/fail status and coverage percentage with full output only on failures. TRIGGER when: code changes need test verification before committing, explicitly asked to run tests, or creating a pull request. DO NOT TRIGGER when: no Python code changed, or running non-pytest test frameworks.

Guide UV installation and migrate Python scripts from legacy shebangs to UV inline metadata (PEP 723). TRIGGER when: migrating scripts to uv, setting up uv for the first time, or converting shebangs to PEP 723 format. DO NOT TRIGGER when: uv is already configured, or user is writing standard Python packages (not standalone scripts).

Analyze a PR for QA needs, check e2e coverage gaps, and create QA sub-tickets when manual testing or new e2e tests are needed. TRIGGER when: PR needs QA analysis for coverage gaps or manual test requirements. DO NOT TRIGGER when: executing QA test cases (use Dev10x:qa-self), or PR has no user-facing changes.

Execute QA test cases on staging using headless Playwright, capture screenshot and video evidence, upload to Linear, and post structured results. TRIGGER when: QA ticket has test cases to execute against staging and evidence is needed. DO NOT TRIGGER when: analyzing PR for QA needs (use Dev10x:qa-scope), or running unit/integration tests (use test skill).

Generate JTBD-driven release notes from git commits between releases. Playbook-powered workflow with configurable ticket patterns, output targets, and categories. TRIGGER when: preparing a release and need to generate changelog or release notes from commit history. DO NOT TRIGGER when: writing individual commit messages, or updating documentation unrelated to releases.

Request PR review — assigns GitHub reviewers and posts Slack notification in one command. Delegates to Dev10x:gh-pr-request-review and Dev10x:slack-review-request. TRIGGER when: PR is ready for review and needs both GitHub reviewer assignment and Slack notification. DO NOT TRIGGER when: PR is draft/WIP, or only need GitHub assignment without Slack (use Dev10x:gh-pr-request-review directly).

Consume structured findings from Dev10x:review and create one standalone fixup! commit per finding via Dev10x:git-fixup. TRIGGER when: Dev10x:review has produced a findings JSON file that needs fixup commits. DO NOT TRIGGER when: no findings file exists, or addressing PR review comments from external reviewers (use Dev10x:gh-pr-fixup).

Review your own branch changes before creating a PR. Reviews diff against base branch, runs automated checks, and produces structured findings with severity, file, line, and suggested fix. Works in attended (pick findings) or unattended (auto-advance to fixer) mode. TRIGGER when: reviewing own branch changes before PR creation, or self-reviewing code quality. DO NOT TRIGGER when: reviewing an external PR (use Dev10x:gh-pr-review), or no changes exist on the branch.

Base scoping skill for technical research and architecture design. Provides reusable scoping workflow for investigating codebases, designing solutions, and documenting decisions. TRIGGER when: performing technical research or architecture design without a specific tracker integration. DO NOT TRIGGER when: scoping a Linear ticket (use Dev10x:ticket-scope), documenting an ADR (use Dev10x:adr), or scoping a project (use Dev10x:project-scope).

Track in-session work items — so open loops are visible and triageable before session end without losing track of parallel work. TRIGGER when: managing in-session task tracking, viewing open loops, or adding work items mid-session. DO NOT TRIGGER when: starting structured work from inputs (use Dev10x:work-on), or wrapping up a session (use Dev10x:session-wrap-up).

Capture and route unfinished work at session end — so nothing is lost when the session closes. TRIGGER when: session ending, user says "wrap up" / "pause" / "done for today", or too many open loops pile up. DO NOT TRIGGER when: mid-session active work with manageable task list, or starting new work (use Dev10x:work-on).

Audit a session's skill usage, compliance, and extract lessons learned. Dispatches parallel subagents for analysis phases — run from a separate terminal. TRIGGER when: session is complete and user wants usage review, or a skill didn't behave as expected. DO NOT TRIGGER when: mid-session during active work, or user is asking about a specific skill's documentation.

Use when creating or improving a local skill and hitting friction — bash commands keep prompting for approval, the skill doesn't appear in MOTD, or it's unclear which frontmatter fields wire up invocability — so you get the Dev10x-specific setup right without hunting through existing skills for examples. TRIGGER when: creating a new skill, fixing skill registration, or scaffolding skill directory structure. DO NOT TRIGGER when: editing skill content without structural issues, or writing non-skill code.

Generate a family-grouped, adaptive-density skill index. Scans local skills and all installed plugins, groups by families.yaml, hides orchestration deps via hidden.yaml, and writes ~/.claude/SKILLS.md (≤45 lines, ≤300 chars/line). TRIGGER when: regenerating SKILLS.md after adding, removing, or renaming skills. DO NOT TRIGGER when: viewing the existing skill index, or editing individual skills.

Remind the agent about available skills when it uses CLI commands that should be handled by skills or MCP tools instead. Reads conversation context to identify the offending command, matches it against a command-to-skill map, and outputs a firm reinforcement message pointing to the correct skill. TRIGGER when: user sees agent using CLI instead of a skill, user rejects a command that should have been a skill, or user says "use the skills". DO NOT TRIGGER when: agent is already using skills correctly, or the CLI command has no skill equivalent.

Post a Slack review request for a PR using per-project config (channel, mentions). Reads configuration from userspace YAML. TRIGGER when: PR needs a Slack review notification posted to the team channel. DO NOT TRIGGER when: Slack not configured, or using the combined Dev10x:request-review skill (which delegates here automatically).

Guide the user through setting up their Slack integration — create a Slack app, configure scopes, store the token in the system keyring, and generate slack-config.yaml. TRIGGER when: setting up Slack integration for the first time, or reconfiguring Slack credentials. DO NOT TRIGGER when: Slack already configured and working, or sending messages (use Dev10x:slack).

Send notifications to Slack channels with support for threads, file uploads, message updates, and user group mentions. TRIGGER when: sending messages, uploading files, or updating messages in Slack channels. DO NOT TRIGGER when: setting up Slack integration (use Dev10x:slack-setup), or posting review requests (use Dev10x:slack-review-request).

Create a properly named git branch for a ticket following project conventions (username/TICKET-ID/[worktree/]short-slug). Ensures latest develop is pulled before creating the branch. Automatically detects worktrees and includes worktree name in branch. TRIGGER when: starting work on a ticket and need a feature branch. DO NOT TRIGGER when: branch already exists for this ticket, or creating a worktree (use Dev10x:git-worktree which creates branches internally).

Create an issue tracker ticket (GitHub issue, Linear, or JIRA) with proper formatting, description structure, and labels. Accepts title, description content, and optional labels. Automatically formats the description with Root Cause, Solution, and Files Changed sections. Returns the created ticket ID. TRIGGER when: a new ticket needs to be created for tracking work. DO NOT TRIGGER when: ticket already exists (use Dev10x:ticket-scope to enrich it), or user wants to update an existing ticket.

Write a JTBD Job Story and apply it to a target (PR description, GitHub issue, Linear ticket, or JIRA ticket). Delegates drafting to the Dev10x:jtbd base skill, then handles the side-effecting write. TRIGGER when: a ticket or PR needs a Job Story written or updated. DO NOT TRIGGER when: JTBD is already present in the target, or user is writing commit messages (use Dev10x:git-commit for that).

Scope Linear tickets with technical research and architecture design. Extends the base scope skill with Linear ticket integration, story point estimation, and acceptance criteria formatting. TRIGGER when: preparing to implement a Linear ticket — scoping technical approach, estimating story points, or writing acceptance criteria. DO NOT TRIGGER when: scoping non-Linear tickets, multi-ticket projects (use Dev10x:project-scope), or new domain areas (use Dev10x:ddd first).

Post-upgrade cleanup — update plugin version paths, ensure base permissions, migrate config files from deprecated locations to canonical Dev10x paths, merge worktree rules, generalize session-specific args, audit for friction-causing patterns via the permission-auditor agent, and clean redundant rules from project settings files. TRIGGER when: plugin version changes, permission prompts keep appearing, config files are at old locations, or user asks to fix permission friction. DO NOT TRIGGER when: permissions are working correctly, or user is asking about non-permission configuration.

Verify that definition-of-done / acceptance criteria are met before closing a task list. Loads executable checks from plugin defaults, applies project overrides (add/remove/replace), runs each check automatically, and prompts the user only for manual items. TRIGGER when: task list is complete and work needs shippability verification before handover. DO NOT TRIGGER when: mid-implementation, or task list has incomplete items.

Start work on any input — ticket URL, PR link, Slack thread, Sentry issue, or free text. Classifies inputs, gathers context in parallel, builds a supervisor-approved task list, and executes adaptively with pause/resume support. TRIGGER when: user provides ticket URLs, PR links, Slack threads, Sentry issues, or free text to start structured work. DO NOT TRIGGER when: simple one-off tasks that don't need structured planning, or parallel fanout of independent items (use Dev10x:fanout).

10 hooks across 6 events