Command Quick Reference

All slash commands at a glance -- grouped by workflow phase

Setup

First-Time Setup

Run once per repo to configure the project.

Command	Description
`/dx-init`	Configure project — ADO mapping, build commands, base branch. Creates `.ai/config.yaml`.
`/aem-init`	Detect AEM structure, append `aem:` section to config. AEM projects only.
`/dx-adapt`	Auto-detect project type, role, toolchain, and build commands. Writes `project.type`, `project.role`, and `toolchain:` section to config.
`/dx-scan`	Deep project scan — discover FE/BE conventions from code, customize rules with real values, generate seed data. Interactive.
`/auto-init`	Scaffold autonomous agent infrastructure (optional).

Recon

Reconnaissance

Quick lookups before starting work.

Command	Argument	Description
`/dx-ticket-analyze`	`<id>`	Quick ticket recon — files, pages, acceptance criteria
`/aem-component`	`<name>`	Find all source files + AEM pages for a component
`/aem-page-search`	`<name>`	Find all AEM pages using a specific component
`/dx-help`	`<question>`	Answer architecture questions from local docs
`/dx-estimate`	`<id>`	Analyze story, produce hours/SP estimation
`/dx-council`	`<question>`	LLM Council — 3 advisors analyze, peer-review, synthesize verdict. Use `council the plan` or `council the implementation`.

Phase 1

Requirements

Fetch, validate, explain, research, and share.

Command	Argument	Description	Output
`/dx-req`	`<id>`	Full requirements pipeline (fetch, DoR, explain, research, share). Detects cross-repo scope when `repos:` exists in config.	All spec files + ADO comments
`/dx-req-tasks`	`<id>`	Create child Task work items with estimates	ADO/Jira tasks
`/dx-req-import`	`<path>`	Validate external requirements document	`explain.md`

Figma

Figma Design-to-Code

Extract, prototype, and verify from Figma designs.

Command	Argument	Description
`/dx-figma-all`	`[id] [URL]`	Full Figma workflow: extract, prototype, verify
`/dx-figma-extract`	`[id] [URL]`	Extract design context, tokens, screenshots from Figma
`/dx-figma-prototype`	`<id>` (opt)	Generate standalone HTML/CSS prototype
`/dx-figma-verify`	`<id>` (opt)	Visually verify prototype against Figma reference

Phase 2

Planning

Generate and validate implementation plan.

Command	Argument	Description	Output
`/dx-plan`	`<id>` (opt)	Generate step-by-step implementation plan. Tags steps with repo names for cross-repo work.	`implement.md`
`/dx-plan-validate`	`<id>` (opt)	Verify plan covers all requirements	Pass/Fail
`/dx-plan-resolve`	`<id>` (opt)	Fix risks flagged by validation	Updated `implement.md`

Phase 3

Execution

Execute plan steps, test, review, commit.

Command	Argument	Description
`/dx-step-all`	`<id>` (opt)	Execute all plan steps autonomously (step + fix loop)
`/dx-step`	`<id>` (opt)	Execute next pending step — implement, test, review, commit
`/dx-step-fix`	`<id>` (opt)	Fix a blocked step — direct fix or corrective steps

Phase 4

Build + Verify

Build, deploy, and run 6-phase verification.

Command	Description
`/dx-step-build`	Build and deploy, auto-fix errors iteratively (max 6 attempts)
`/dx-step-verify`	6-phase verification: compile, lint, test, secrets, architecture, code review
`/dx-axe <URL>`	Accessibility testing using axe MCP Server

AEM

AEM Verification

Component snapshots, verification, and demo capture.

Command	Argument	Description
`/aem-snapshot`	`<component>`	Baseline component state before changes
`/aem-verify`	`<component>`	Verify component after deployment, create test page
`/aem-fe-verify`	`<component>`	Screenshot and compare against Figma/requirements
`/aem-editorial-guide`	`<component>`	Screenshot dialog, write authoring guide
`/aem-qa`	`<id>` (opt)	Full QA agent — navigate, check rendering, create Bug tickets
`/aem-qa-handoff`	`<component> <id>`	Generate testing steps for QA team, post to ADO

Bug Fix

Triage, verify, and fix bugs.

Command	Argument	Description
`/dx-bug-all`	`<bug-id>`	Full bug workflow: triage, verify, fix
`/dx-bug-triage`	`<bug-id>`	Fetch bug, find affected component
`/dx-bug-verify`	`<bug-id> [before\|after\|qa]`	Reproduce via Chrome DevTools. `before`: confirm bug. `after`: verify fix locally. `qa`: verify fix on QA post-merge.
`/dx-bug-fix`	`<bug-id>` (opt)	Generate fix plan, execute, create PR

Phase 6

Pull Request

Create, review, answer, and fix PRs.

Command	Argument	Description
`/dx-pr`	`<id>` (opt)	Create pull request via ADO MCP
`/dx-pr-commit`	`[pr]`	Commit with WI linking; add `pr` to also create a PR
`/dx-pr-review`	`<PR URL>`	Review a PR — analyze diff, post comments, propose fixes. Checks sibling FE repos for field impact on dialog changes.
`/dx-pr-review-all`	none	Batch-review multiple open PRs
`/dx-pr-answer`	`<PR URL>` (opt)	Answer open PR comments, apply agree-will-fix changes
`/dx-pr-review-report`	`<PR URL>`	Generate categorized report, post to wiki

Phase 7

Documentation

Generate wiki docs, authoring guides, and QA handoffs.

Command	Argument	Description
`/dx-doc-gen`	`<id>`	Generate wiki docs from spec files, post to ADO wiki
`/dx-doc-retro`	`<id>`	Retroactive wiki docs for completed stories
`/aem-doc-gen`	`<id>`	AEM authoring guide with dialog screenshots
`/aem-qa-handoff`	`<component> <id>`	Generate testing steps for QA team

DoD

Definition of Done

Validate deliverables against the DoD checklist.

Command	Argument	Description
`/dx-req-dod`	`<id>`	Check Definition of Done and auto-fix gaps

Agents

Agent Roles

Specialized agent pipelines.

Command	Argument	Description
`/dx-agent-all`	`<id> [autonomous]`	Full pipeline: requirements, plan, execute, review, PR
`/dx-agent-re`	`<id>`	RE Agent — structured requirements spec
`/dx-agent-dev`	`<id>`	Dev Agent — implement from RE spec

Automation

Deploy and manage autonomous agent infrastructure.

Command	Description
`/auto-init`	Scaffold `.ai/automation/`
`/auto-provision`	Create AWS resources (DynamoDB, SQS, S3, Lambda, API Gateway)
`/auto-pipelines`	Import ADO pipeline YAMLs, set variables
`/auto-deploy`	Deploy Lambda code
`/auto-lambda-env`	Set Lambda environment variables
`/auto-webhooks`	Configure ADO service hooks + build policy
`/auto-alarms`	Create CloudWatch alarms, subscribe email
`/auto-doctor`	Full health check: files, pipelines, Lambda state
`/auto-status`	Dashboard: DLQ depth, token budget, rate limits
`/auto-eval`	Run evaluation framework against test fixtures
`/auto-test`	Local dry-run against real ADO data

Utility

Utility + Maintenance

Health checks, upgrades, and ejection.

Command	Argument	Description
`/dx-doctor`	`[dx\|aem\|seed-data\|auto\|all]`	Check health of all dx workflow files. Warns on stale `project.yaml` files.
`/dx-upgrade`	`[dx\|aem\|auto\|all]`	Fix all issues found by dx-doctor. Migrates legacy `project.yaml` fields into `config.yaml`.
`/dx-eject`	`[dx\|aem\|auto\|all]`	Eject plugin assets into local repo
`/aem-refresh`	none	Update `.ai/project/` seed data
`/aem-doctor`	`[components\|osgi\|dispatcher\|all]`	Check AEM project infrastructure health

Cross-Repo

Cross-Repo Ticket Handling

Some tickets span multiple repos. The workflow handles this gracefully.

How It Works

Requirements phase (/dx-req) discovers which repos need work
research.md and explain.md list the repos involved
Plan and execution only cover the current repo
Switch to the other repo and run the same workflow there

Pipeline Mode (Automated)

When DX_PIPELINE_MODE is set, code-writing coordinators (dx-bug-all, dx-agent-all, dx-req-dod) check if the work targets another repo. If so, they write .ai/run-context/delegate.json and STOP. A post-Claude YAML step reads it and queues the equivalent pipeline in the target repo.

Manual cross-repo workflow

# In backend repo:
/dx-req 2416553
/dx-plan
/dx-step-all

# In frontend repo (same ticket, plans FE steps only):
/dx-req 2416553
/dx-plan
/dx-step-all

Learning

Self-Learning

Coordinator skills automatically log run metrics and patterns. Each subsequent run gets smarter.

File	Contents	Written By
`.ai/learning/raw/runs.jsonl`	Run records — timestamp, ticket, flow, step statuses, fix/heal counts	All three coordinators
`.ai/learning/raw/fixes.jsonl`	Fix patterns — error type, fix description, success/failure	`dx-step-all`
`.ai/learning/raw/bugs.jsonl`	Bug patterns — component, root cause, files changed	`dx-bug-all`

Pattern Promotion

When dx-step-all detects a fix pattern with 3+ successes and 0 failures, it promotes it to .claude/rules/learned-fix-*.md — auto-loaded by Claude on every future run.

Aggregation Skills

Run /dx-learn to aggregate raw JSONL data into readable markdown summaries. Run /dx-retro for weekly retrospective with success rates, trends, and suggested actions.

Committing Learning Data

.ai/learning/raw/ contains JSONL machine data — safe to commit or gitignore. .claude/rules/learned-*.md should be committed (they are project-level rules).

Workflow

DoR to BA Feedback to Share Plan

Incremental requirements loop with idempotent steps and BA checkbox interaction.

Incremental Requirements Loop

Each step is idempotent -- already-completed steps are skipped on re-run.

req /dx-req Full pipeline

Example workflow

/dx-req 2416553                  # Full pipeline: fetch, DoR, explain, research, share

Dependency Chain

fetch → dor → explain → research → share. The BA checkbox loop between dor steps is the only human gate in the chain. All other transitions are automatic.