Claude Code Skills & Workflows

This page documents the workspace slash-commands that engineers use through Claude Code (/Users/aiqlick/development/.claude/commands/). They are local to the workspace, not shipped with any one repo, and they orchestrate the day-to-day operational flows: ticket triage, code ship, dev verification, documentation, and customer reply.

Audience: anyone with super-admin or documentation access. The instructions assume you are running Claude Code against the AIQLick monorepo workspace.

Overview

Every box is a separately-invokable slash command. The orchestrator /ticket-fix calls each in order with the right gates, but you can break out at any step or run them by hand.

Daily entry points

/health                          # is everything up?
/support-tickets triage          # what's mine or unassigned?
/ticket-fix SUP-XXXXX            # full fix loop for one ticket

That's the start-of-day. Everything else flows from a chosen ticket or an ad-hoc code change.

The five lifecycle skills (added 2026-04-24)

Skill	Role	Defaults
/ticket-detail SUP-X	Drill into one ticket — header + message thread + audit log + suggested next steps	prod env; accepts SUP-NNNNN or uuid
/ticket-reply SUP-X "..."	Atomic reply: updateTicketStatus + assignTester + sendSupportReply (or addInternalNote). Refuses "please retest" replies without a verification signal	prod env; verification gate on by default
/verify-on-dev SUP-X	Scaffold /tmp/sup_<N>_e2e.py with auth + GraphQL + voice/agent helpers, run it, report PASS/FAIL	dev env only
/watch-deploy	Wait for one GitHub Actions run + verify the matching health endpoint	auto-detects project + branch
/ticket-fix SUP-X	End-to-end orchestrator chaining all of the above	stops before dev→main promotion

Pre-existing skills you'll use alongside

Skill	Use when
/support-tickets [filter]	Triage / list view. Prod by default; env=dev opt-in
/ship [target] [msg]	Commit + push + poll deploy. Default dev; main/prod for production promotion
/test	Run unit/safe tests for the current project with smart defaults
/docs-update	Update Docusaurus pages to reflect this session's changes; ships to docs.aiqlick.com by default
/gql 'query { ... }'	One-off GraphQL call against dev (default) or prod
/db-query	Read-only SQL against dev/prod RDS via SSM port forwarding
/browse	Drive a real browser via Playwright MCP for UI verification
/cross-project	Coordinate a change that spans backend + background-tasks + frontend
/health	Quick smoke across all envs
/deploy-status	Full snapshot of ECS services + RDS + ECR + Amplify + GH Actions
/sso-login	Refresh AWS SSO when expired

Canonical chains

Customer ticket lifecycle

/support-tickets triage  →  /ticket-detail SUP-X  →  /ticket-fix SUP-X
                                  │
                                  ├──→  /ticket-reply SUP-X "..."   (close without code)
                                  └──→  /report-ticket "..."        (file related new ticket)

/ticket-fix internally runs: /ticket-detail → Plan mode → code → /test → /ship dev → /verify-on-dev → (gated) /ship main → /ticket-reply status=TEST tester=reporter "..." → /docs-update. Stops on its own at the plan-approval and dev→main promotion gates.

Code change (no ticket)

[edit]  →  /test  →  /ship dev  →  /watch-deploy  →  /ship main  →  /docs-update

/ship polls deploy inline so /watch-deploy is only needed standalone (e.g. waiting on a teammate's PR).

Investigation / triage (read-only siblings)

/db-query   ↔   /gql   ↔   /browse   ↔   /check-logs

Pick by signal type: DB row state → /db-query; API behavior → /gql; UI rendering → /browse; runtime errors → /check-logs.

Schema / data model change

/prisma-change  →  /test  →  /ship dev  →  /add-graphql-op  →  /ship dev  →  /docs-update

/ticket-fix — orchestrator details

Stages, in order:

1. Boot — resolve SUP-X to uuid; dry-run flag prints the plan and stops.
2. Read — /ticket-detail SUP-X so both you and Claude have the full context. Halts if the ticket isn't assigned to the current operator.
3. Plan — Plan mode, with a written plan file at ~/.claude/plans/<sup>-<title>.md. Exits via ExitPlanMode and waits for user approval.
4. Code + test — edits, then /test for the touched project(s).
5. Ship to dev — /ship dev "fix(scope): … (SUP-X)". Single commit per ticket (per feedback_one_commit_per_ticket).
6. Verify on dev — /verify-on-dev SUP-X template=…. Pick helpers based on the failing path (auth,cv-state for CV mutations, auth,agent-chat for agent tools, auth,voice-ws for voice).
7. Promote to main — gated. Per feedback_no_unsolicited_main_pr, the orchestrator stops and asks before opening the dev→main PR. Pass stop-at-dev to skip this stage entirely.
8. Close the ticket — /ticket-reply SUP-X status=TEST tester=reporter "<retest msg>". The verification gate accepts the dev e2e from stage 6.
9. Docs — /docs-update. Default: ship to docs.aiqlick.com. Pass skip-docs to skip.

Flags: dry-run, stop-at-dev, skip-docs, env=dev.

/verify-on-dev — verification scaffold

Drops a Python script at /tmp/sup_<NNNNN>_e2e.py (or /tmp/verify_<slug>_e2e.py for non-ticket changes) with the auth + GraphQL boilerplate already filled in. You complete the # TODO blocks (pre-state capture, the prompt or mutation that exercises the failing path, post-state capture, assert statements) and the skill runs it.

Helper blocks (selected via template=):

Block	Provides
auth	sign_in() → token, gql_post(url, q, vars, token)
cv-state	fetch_cv(token) — skills + jobPreference + experience for the dev test user
agent-chat	chat(conv_id, prompt, token, forced_tools=None), start_conv(agent_id) (graphql-ws)
voice-ws	voice_run(conv_id, pcm_bytes) (binary PCM stream on /voice/ws/{conv})
tickets	fetch_tickets(token, **filters)

The PASS line in the conversation transcript is what /ticket-reply looks for as the verification signal. Without it, the customer-visible reply is blocked.

Idempotent on filename — re-running on an existing script uses it as-is. Pass regenerate to overwrite.

/ticket-reply — atomic close-loop

Bundles three mutations that always go together:

assignTester(testerId: ID, ticketId: ID!)             # nullable testerId → null unassigns
updateTicketStatus(status: String!, ticketId: ID!)    # String not enum
updateTicketPriority(priority: TicketPriority!, ...)  # Enum, not String
sendSupportReply(input: SendSupportReplyInput!)       # customer-visible
addInternalNote(input: AddInternalNoteInput!)         # internal-note flag → routes here

All three input shapes (SendSupportReplyInput, SendTicketMessageInput, AddInternalNoteInput) share the same fields: attachments, content, ticketId. The isInternalNote boolean appears only on the read side (TicketMessageOutput) and is set by which mutation route was used, not by an input field.

Useful flags: status=TEST, tester=reporter|me|<email>, priority=HIGH, internal-note, dry-run, --no-verify (override the verification gate).

/watch-deploy — single-run wait

For a single GitHub Actions run, waits via gh run watch, then verifies the matching health endpoint:

Project	Workflow	Health (dev / main)
background-tasks	aws-deploy.yml	https://ai-dev.aiqlick.com/health / https://ai.aiqlick.com/health
aiqlick-backend	aws-deploy.yml	https://api-dev.aiqlick.com/health / https://api.aiqlick.com/health
aiqlick-frontend	(Amplify, polled via aws amplify list-jobs)	https://dev.aiqlick.com / https://www.aiqlick.com
documentation	deploy.yml	https://docs-dev.aiqlick.com / https://docs.aiqlick.com

/ship already polls inline — use /watch-deploy standalone for ad-hoc waits or to babysit a teammate's PR.

Defaults & gotchas

• Production is the default for ticket skills. /support-tickets, /ticket-detail, /ticket-reply, /report-ticket all target prod unless you pass env=dev. Real customer tickets live on prod; dev is mostly noise.
• /ship defaults to dev. /ship main is opt-in and triggers production. The skill won't ask twice — passing main IS the authorization.
• /ticket-reply has a verification gate. Refuses "please retest" wording (or status=TEST) without an in-conversation verification signal. Override with --no-verify only when you really mean it.
• /docs-update ships all the way to prod docs by default. Low-risk content (no DB, no Stripe). Pass stop-at-dev or no-ship to hold.
• tester=reporter in /ticket-reply resolves to the ticket's createdBy.email automatically — saves typing.
• Move fixes to TEST, not WAITING_ON_CUSTOMER — the support portal hides WAITING_ON_CUSTOMER by default; tickets parked there look untouched.
• One commit per SUP ticket. /ticket-fix enforces this; never batch unrelated bugs into a single commit.
• /verify-on-dev is dev-only. No prod URLs in the scaffold by design — verification happens before promotion.

Where this lives

• Skills: /Users/aiqlick/development/.claude/commands/*.md (workspace-local, per-user)
• Workflow memory: /Users/aiqlick/.claude/projects/-Users-aiqlick-development/memory/reference_skill_workflows.md
• Plans (per-session): ~/.claude/plans/
• E2E scripts: /tmp/sup_<NNNNN>_e2e.py (regenerated per session)

Related

• Monitoring & Operations
• Support Agent Account Consolidation