sasso-hq

Teach the Claude Agent SDK (claude-agent-sdk) and how to layer it behind the reference app's Brain interface — the agent loop, in-process tools, MCP, and context management. Use when a bot needs an agent that runs tools/files/MCP autonomously, when outgrowing a hand-rolled messages.create loop, or when upgrading ClaudeBrain without changing respond().

Teach the raw Anthropic Python SDK behind the reference app's Brain — messages.create, the tool-use loop, streaming, and prompt caching. Use when implementing or extending a bot Brain, calling Claude directly, adding tools/streaming/caching to messages.create, or asking how ClaudeBrain talks to the model.

Make a public Claude bot safe with deterministic guardrails — block prompt-injection on input, redact PII (email/phone/SSN/card) on input and output, and short-circuit blocked messages with a canned reply. Use when hardening a bot for public traffic, adding input/output screening, or filling the chatbot-toolkit Guardrails seam.

Persist bot conversation history in Postgres using the chatbot-toolkit reference app's PostgresSessionStore — asyncpg, a lazy pool, and a temp-Postgres test. Use when sessions must survive restarts, moving a bot off in-memory storage, or adding a durable SessionStore.

Get the chatbot-toolkit reference app onto a public HTTPS endpoint Meta will accept — build the bundled Dockerfile and deploy to a container PaaS (Fly / Railway / Render) with env/secret config, or tunnel to your laptop for dev. Use when deploying a bot, Dockerizing the reference app, setting up a webhook URL Meta accepts, configuring deploy secrets, or exposing a local bot for webhook testing.

Connect the chatbot-toolkit reference app to Meta — create a Meta App, pass the webhook verify handshake, validate X-Hub-Signature-256, and send via the Meta Graph API for WhatsApp and Instagram. Use when setting up a Meta App, wiring a WhatsApp or Instagram webhook, debugging webhook verification or signature failures, parsing inbound payloads, or sending WhatsApp templates/media or Instagram DMs.

Stand up a full-stack Claude-powered WhatsApp bot from the chatbot-toolkit reference app — FastAPI webhook, Channel/Brain/SessionStore/Guardrails modules, end to end. Use when starting a new chatbot, scaffolding a messaging bot, or wiring Claude to WhatsApp/Instagram.

Test a Meta messaging bot in the chatbot-toolkit stack without live services — simulate webhook payloads from captured fixtures, sign them like Meta does, mock the Graph and Anthropic APIs, and assert behavior through public interfaces. Use when writing tests for a bot, simulating a webhook, faking an inbound WhatsApp/Instagram message, mocking the Graph or Anthropic API, testing the brain or guardrails, or asking how the reference app tests itself.

Find deepening opportunities in a codebase, informed by the domain language in CONTEXT.md and the decisions in docs/adr/. Use when the user wants to improve architecture, find refactoring opportunities, consolidate tightly-coupled modules, or make a codebase more testable and AI-navigable.

Build or refresh an offline structural map of a repo (a code graph) that other skills can read. Use before improve-codebase-architecture, or when you want a real call/import/reference graph of the codebase instead of reasoning from memory.

Use when you want to hand work to autonomous Claude workers instead of doing it inline — files an issue and spawns a worker in an isolated git worktree, then tracks and reaps it. The runtime tail of the SDD pipeline. Commands - /dispatch /adopt /status /reap /pool.

Audit and fix accessibility (a11y) issues against WCAG 2.2 AA across React-family web and React Native — semantics, keyboard, focus, accessible names, contrast, and motion. Use when auditing a UI for accessibility, fixing a11y bugs, adding ARIA or focus management, reviewing for WCAG compliance, or making components usable with a screen reader and keyboard.

Add motion that communicates and stays cheap — animate compositor-only properties (transform/opacity), drive it off the main/JS thread, and honor reduced-motion preferences on web and React Native. Use when adding a transition or animation, building a motion-heavy interaction, fixing janky or expensive animation, or making motion respect prefers-reduced-motion / OS accessibility settings.

Design React-family and React Native components with clear composition, prop boundaries, and ownership — when to split, when to compose, what to lift, and what to keep local. Use when creating a new component, refactoring a bloated one, deciding a component's props/children API, or reviewing component structure.

Handle async data the house way — treat server state as a cache (not useState + useEffect), render loading/error/empty/success explicitly, fetch with keys/dedup/revalidation, and mutate optimistically then reconcile. Use when fetching data in a component, adding caching, wiring loading/error states, building a mutation, or reviewing data-fetching code.

Debug frontend web issues against a live Chrome via the Chrome DevTools MCP instead of guessing from source — reproduce the bug in the running page, then read the real console, network, DOM, and performance signal. Use when a page throws a console error, a network request fails or returns the wrong data, layout or styling renders wrong, or an interaction janks, and when first wiring the DevTools MCP into a repo.

Build accessible, well-validated forms in React-family web and React Native without reinventing the wheel — schema-driven validation, when validation runs, accessible errors, submission state, and mobile inputs. Use when building or reviewing a form, choosing a form/validation library, wiring client + server validation, or fixing form accessibility.

Diagnose and fix frontend performance — Core Web Vitals (LCP, INP, CLS), JavaScript bundle size, and React render cost — with a measure-first method. Use when a page loads or responds slowly, a bundle is too large, a list or view janks, Lighthouse / Web Vitals scores are poor, or before shipping a perf-sensitive feature.

Test React-family and React Native components and user flows by behavior, not implementation detail — accessible queries, real user interaction, async awaited honestly, and the network mocked at the boundary. Use when writing or reviewing component/integration tests, deciding what to assert, fixing flaky or brittle tests, or choosing what to mock.

Structure React Native (and React-family web) navigation correctly from the start — what's a route vs local state, typed params, stacks/tabs/modals, back behavior, and deep linking. Use when adding navigation to an app, adding a screen or flow, choosing React Navigation vs Expo Router, deciding what a route's params should carry, or reviewing navigation structure.

Keep React Native (and React-family) apps smooth — list virtualization, native-bridge cost, and render cost. Use when a list janks or drops frames, when scrolling or gestures stutter, when a screen re-renders too much, or when profiling a slow mobile UI.

Choose where state belongs — local, server-cache, global-client, or URL — instead of reaching for one tool (Redux, Context, a global store) reflexively. Use when adding state to a feature, deciding whether something belongs in a global store, wiring up server data, or untangling prop-drilling and over-globalized state.

Apply design tokens and a coherent styling architecture — one source of truth for color, spacing, type, and theming — instead of ad-hoc CSS and magic numbers. Use when setting up styling for a new app, taming scattered or duplicated styles, building a light/dark theme, choosing a styling approach (CSS Modules, utility classes, CSS-in-JS, RN StyleSheet), or reviewing styling architecture.

Build touch and gesture UX that feels native — thumb-sized targets, feedback on touch-down, and continuous gestures (drag, swipe, pinch) that track the finger on the UI thread without stealing scrolls. Use when adding a gesture, building a swipeable/draggable component, fixing janky or unresponsive touch, sizing tap targets, or reviewing touch interactions on web or React Native.

Use when reviewing code, a diff, a branch, or a PR to the org's standard. Wraps the review mechanic with house quality gates — the org entry point for code review.

Use when writing a commit message or preparing a commit in any org repo. Enforces the house Conventional Commits format.

Use when an engineer first installs hq-core or asks how the org's agent setup works. Introduces the hub, grants the permissions the flow needs, ensures auto-updates work, sets up the Context7 docs MCP, asks what they're working on, and recommends + installs the right skills and workflow playbook.

Use when an engineer describes what they're working on and wants to know which skills and workflow to use. Maps a free-text task to the org's skills and workflow playbooks, then offers to install anything missing.

Use when starting any non-trivial feature (3+ steps or an architectural decision). Orchestrates the org's spec-driven development pipeline from interview through reviewed, merged code.