Write tests following TDD cycle and BDD conventions with domain-first coding philosophy
Produce a shareable, non-technical feature guide as a published Artifact — live screenshots of every surface in the feature's story, captured from the running dev app with Playwright (including interaction states: open menus, drawers, drill-downs), annotated with numbered callout dots and plain-language legends, organized around the feature's own mental model (levels, flow, or lifecycle), with "reading the numbers", "what it can't show (yet)", and "who can see it" sections. Self-contained HTML (base64-embedded images, light + dark themes, project brand tokens) published via the Artifact tool and iterated in place at the same URL.
Build or refactor a great Shopify `maintenance_tasks` Task (Rails) — the full design, not just batching. Starts from the decision that shapes everything — which of the four collection shapes fits: an AR **Relation** (per-record `process`), a **`Model.in_batches(of: N)`** batch enumerator (one set-based bulk write per batch), a plain **Array** (small finite computed collections like catalogs or date ranges), or **`no_collection`** (a single atomic SQL statement, no iteration) — then layers on idempotency, large-table timeout rules, callback/PaperTrail-aware writes, and the opt-in features (dry-run, attributes, throttling, callbacks). Encodes the traps agents hit repeatedly: a collection Relation must carry NO `ORDER BY`/`LIMIT` (the cursor adds its own PK ordering and it raises at runtime); `find_each` ignores a custom `order`; never override `count` for a batch enumerator; prefer the collection API over `no_collection` so you get progress + pause/resume; data backfills belong in a task, not a migration; use `
Write code comments deliberately — sparingly, only when they add real value, in plain natural-language prose rather than dense justification. The default is no comment: let names and structure speak. A comment earns its place only when it tells a future reader something they could NOT infer from the code — a non-obvious WHY, a gotcha, a load-bearing decision, or a grep anchor for a source-of-truth table. Strips the recurring failure modes: restating the method name, narrating mechanics the reader can see, baking in transient snapshot facts (row counts, "for V1"), citing planning docs, sprinkling ADR refs on routine code, and writing in a verbose PR-description register. Also fixes the VOICE — terse, present-tense, stating the noun-fact or the gotcha-with-"so". Use BEFORE writing or editing any inline/method/class comment, and when reviewing or auditing comments in a changeset. If you are about to type a `#` comment in Ruby (or `//`, `/* */`, `<%# %>` elsewhere), this applies. Triggers: writing a new method/cl
Decide WHERE new domain code lives so a codebase organized by bounded context stays predictable as contexts get added — the rule a contributor (agent or human) follows before introducing a new domain noun. Models the domain in two coordinates: which bounded context owns the code (slices by meaning) and which layer it sits in (slices by dependency direction), with one hard rule — dependencies point down, a lower layer never names a higher one. Places behavior by KIND not amount (record / domain / framework), namespaces by ownership not reference, names from domain language not one customer's vocabulary, and treats boundary purity as a default with an evidence-based escape valve, never a tax. The durable rule lives here; each project's own contexts table and migration state live in its .claude/bounded_contexts.md, which this skill reads (and offers to scaffold when missing). Loads a frameworks/<stack>.md appendix for stack-specific placement (e.g. Rails directory coupling) and degrades to generic shapes when no
Systematically answer "where does this data actually come from?" questions — is X the source of truth, why did Y stop updating, which table feeds this surface — by combining production-query evidence with code-path and git-history tracing, then producing an evidence-grounded results document where every claim cites a query result or a file:line. Enforces a strict evidence-first discipline: frame competing hypotheses, trace write paths before read paths, profile the grain BEFORE filtering, reconcile by a globally-unique key, quantify coverage and leaks, and refute your own hypotheses out loud. No claim ships without a citation; no number ships without the query that produced it. Opportunistically uses any connected MCP servers (read-only production DB, hosting/deploy logs, observability) to deepen the evidence, and degrades gracefully to local tooling when they aren't present.