davidteren

Make a Rails app installable and offline-capable — web app manifest, service worker, install prompt, offline/cache states, and (optionally) push — built on Rails 8's native PWA support, not a hand-rolled service worker. Composes Rails 8 native PWA (app/views/pwa/manifest.json.erb + service-worker.js + the routes), the ui.sh family + frontend-design for install/offline UI, ie-experience-reviewer for the offline UX, and a Chrome DevTools Application-panel installability check. Use when the user says "make this a PWA", "make it installable", "add a web app manifest / service worker", "work offline", "add to home screen", or "installable web app". Loops over a list of apps/surfaces. Not for general front-end work (use dte-ux) or native mobile (Hotwire Native is a different toolkit).

Architectural review of a Rails app, a subsystem, or a vertical slice, producing a written findings doc. Composes Augment context retrieval, layered-rails analyzers, intent-engineering audit, majestic Rails reviewers, and a ponytail over-engineering pass into one severity-ranked report. Use when the user asks to "review the architecture", "do an arc review", "assess the structure/design", "find architectural issues / god objects / fat models / layering problems", or to review a slice/subsystem. Loops over a list of slices when given several. Not for line-by-line PR/diff review (use dte-deep-reviewer) or for planning fixes (use dte-arc-plan).

Audit a test suite for real value, not just presence — coverage gaps AND test quality (weak assertions, over-mocking, implementation-coupled/brittle tests, missing edge/error/integration paths), plus mutation testing where available to prove tests actually fail when code breaks. Composes SimpleCov, rails-testing (Minitest), the ce-code-review testing persona, and mutant. Use when the user says "audit the tests", "are these tests any good", "check test coverage/quality", "do the tests actually test anything", or after a feature lands. Loops over a list of files/modules. Not for writing new tests (use minitest-coder / rails-testing) — this judges existing ones.

Turn architectural findings, a spec, a bug report, or an "improve area X" request into concrete, validated implementation plan(s) — always built with compound-engineering's ce-plan and validated with intent-engineering's ie-validate-plan. For a massive task it decomposes the work into many small, independently-shippable plans (loop), each ce-planned and validated, and emits a plan index that dte-arc-work then completes. Use when the user says "plan the fixes", "make a plan(s) from these findings", "plan this bug/refactor/feature", "break this big thing into plans", or hands over a dte-arc-review doc. Not for executing plans (use dte-arc-work) or producing findings (use dte-arc-review).

The full cycle for a task, bug, area, or a whole plan index — review, plan, do the work, then verify — with quality gates and progress reporting throughout. Composes dte-arc-review (or a light scan), dte-arc-plan, ce-work, ce-simplify-code/ponytail, and dte-deep-reviewer + dte-test-auditor to verify. Loops over a list of tasks/bugs OR over a dte-arc-plan INDEX worklist to complete many plans (one branch + gate + report each). Use when the user says "fix this", "do the work", "implement this plan", "work through these plans/tasks", or "handle this end to end". Stops for review after each item by default; --ship to auto commit/PR. --quick for a small bug, --deep for a real change. Not for a pure root-cause bug hunt (use dte-debug), a full-stack feature with UI (use dte-feature), an upgrade/data migration (use dte-migrate), or setting up an autonomous batch loop (use dte-loop).

Full-stack new feature spanning front-end AND back-end — plan, implement, and verify across architecture/back-end AND UI/UX/front-end, making sure BOTH are solid. Composes dte-arc-plan (validated plan), dte-arc-work (gated build), dte-ux + the ui.sh family for the front-end, and dte-deep-reviewer + ie-experience-reviewer to verify both layers. Use when the user says "build this feature", "ship this idea end to end", "add <feature> with a UI", or describes something that needs both a model/controller/job AND a screen. Loops over a list of features. Not for a back-end-only change (use dte-arc-work), pure UI (use dte-ux), or just defining the what (use dte-spec).

Plan and execute a safe upgrade or migration — a Rails version bump, gem upgrades, or a schema/data migration — incrementally, reversibly, gated at every step. Composes gemfile-upgrade + gemfile-organize (dependency moves), database-admin + database-optimizer (schema/data), gem-research (is an upgrade safe/maintained), ce-plan/ce-work, and the project gate after each step. Use when the user says "upgrade Rails/this gem", "bump dependencies", "migrate the schema/data", "backfill this column", "zero-downtime migration", or "update our dependencies". Loops over a list of upgrades. Not for an architecture/structure migration (use dte-arc-work from a dte-arc-auditor roadmap) or a code bug (use dte-debug).

Mine session history and recent work to recommend which tools, skills, plugins, or agents to adopt next — and flag overlap with what is already installed. Composes ce-sessions (prior-session synthesis), MemPalace history/knowledge-graph, the overlap logic from the skill-vet design, and light web research for candidates. Use when the user asks "what tools should we add", "scan our history for gaps", "what are we missing", "what would help based on what we do", or "tooling review". Optional loop over time windows or topics. Produces a recommendations doc; it does not install anything. Not for reviewing code or a PR (use dte-deep-reviewer), app architecture (use dte-arc-review), or auditing the dte-* skills themselves (use dte-skill-audit).

Author and validate Hotwire Native path configuration (the JSON that drives native push/replace/modal/tab navigation on iOS + Android), and the Rails-side turbo_native_app? + request-variant setup. Use when a native screen opens with the wrong presentation (pushed instead of modal, doesn't switch tabs), when adding a new native route, when setting up native navigation for one Rails app across iOS + Android, or when web chrome (top nav) leaks into the native apps. Provides a starter config, a schema/footgun validator, and an iOS↔Android drift check.

Write small, Turbo-safe, server-driven Stimulus controllers, and catch the mistakes that fail at runtime or leak. Use when adding a Stimulus controller, wiring elements that arrive via Turbo Streams/Frames, passing config from the server via the Values/Classes API, or debugging a controller that doesn't connect / a missing-target error / a listener that double-fires after Turbo navigation. Provides annotated templates and a controller linter.

Scope navigation to a region with Turbo Frames correctly, and catch the wiring mistakes that fail silently. Use when adding a turbo_frame_tag (a turbo-frame element), driving a frame from an outside link/form, lazy-loading a panel (src + loading: :lazy), inline-editing a row, or debugging a frame that does nothing / a click that navigates nowhere / a filter form that loses focus / duplicate frame ids from a collection. The region-scoped complement to targeted streams (turbo-streams-patterns) and morph refreshes (turbo-morphing).

Create and validate Strada / Hotwire Native bridge components across web (Stimulus), iOS (Swift), and Android (Kotlin). Use when adding native UI driven by the web — a native menu, share button, toolbar, native form submit — to a Hotwire Native app, or when a bridge component "works on web but not in the app", a native control is missing/duplicated, or a value sent from the web never arrives natively. Generates the three platform halves from one component name and lints the cross-platform contract for name mismatches and silently-dropped payload fields.

Upgrade a Rails 7 app to Rails 8 safely, and catch the subtle test-suite flake it introduces. Use when bumping Rails 7.x to 8.x (or auditing readiness), when planning a Ruby/Rails version bump, or when Rails 8 tests fail intermittently with "undefined method 'login_path'/'root_path'" / pass on serial but flake on parallel runs. Provides a pre-flight audit, a detector + fix for the LazyRouteSet route-test flake, and a 7→8 checklist grounded in a real upgrade.

Build secure DB-backed token session auth in Rails — one mechanism for web, Action Cable, and Hotwire Native, with Current attributes and secure-by-default controller concerns. Use when adding login/sessions to a Rails app, when web and native clients need to share authentication, when you need revocable server-side sessions (logout/kick a device) instead of stateless JWTs, or when auditing existing auth for user-enumeration, plaintext tokens, readable cookies, or opt-in-auth mistakes. Provides templates and a security audit.

Apply Turbo 8 page refreshes with morphing and broadcast refreshes correctly, and avoid the morphing footguns. Use when adding smooth page refreshes (turbo_refreshes_with / turbo-refresh-method morph), broadcasting live updates with broadcasts_refreshes, deciding between morph-refresh vs targeted Turbo Streams vs frames, or when morphing resets browser state (an open details or dialog element, popovers, scroll, focus, JS widgets) after a refresh. Provides a decision guide and a morph-readiness checker.

Build targeted Turbo Streams correctly — model broadcasts over Action Cable, custom stream actions, authorized stream channels, and Kredis presence. Use when adding real-time/live updates (chat append, replace a card, toggle a class), writing a custom turbo-stream action, securing who can subscribe to a record's broadcasts, or debugging a stream that does nothing / a custom action that's ignored / broadcasts leaking to the wrong user. The surgical complement to the morph page-refresh model (see turbo-morphing).

Audit a whole codebase, subsystem, or feature against the intent-engineering lenses (predictability, convention, simplicity, experience, and architecture on supported frameworks) and produce a posture report — per-dimension 0-10 scores plus the top surprise/convention/complexity/UX/structural gaps. Use to assess an existing codebase or area, not a specific diff. Sampling-aware for large targets.

Scaffold Intent Engineering project config into a repo's .intense/ directory — ways-of-working, pattern policy (allow/block/approved), and architecture thresholds — so the team can tune the lenses and commit the settings. Stack-aware menu; idempotent (never clobbers existing config without confirmation). Use to set up or extend a project's .intense/ config.

Review code changes through the intent-engineering lenses (predictability, convention, simplicity, experience, and architecture on supported frameworks) — surfacing surprise, non-idiomatic patterns, needless complexity, UX gaps, and structural anti-patterns. Default (interactive) mode applies safe, verified fixes and commits on a clean tree (never pushes); mode:agent reports JSON only. Use on a PR, branch, or local changes before merging.

Validate a plan, spec, or requirements document against the four intent-engineering lenses before implementation — surfacing surprising designs, non-idiomatic or reinvented approaches, needless complexity/scope, and missing UX decisions (states, flows, IA, accessibility). Returns dimensional 0-10 ratings and the gaps to resolve first. Use when a plan or spec doc exists.

Inject intent-engineering principles into the planning phase — surface the least-astonishment, convention, simplicity, and UX considerations relevant to the work being planned, as a tailored advisory checklist. Lightweight and non-blocking; use while drafting a plan or thinking through an approach, before a full plan doc exists. For validating a finished plan, use ie-validate-plan instead.

Deterministic websocket / Turbo-Stream HARDENING checker for any ActionCable or Turbo Streams Rails app — flags the security failures that produce no error: a channel that streams without authorizing the subscriber (broadcast eavesdropping), `constantize`/`safe_constantize` on a client-supplied params/data string (arbitrary class load / RCE-ish), Action Cable request-forgery protection disabled in a non-dev env (CSWSH), and — as caveated heuristics — a missing `allowed_request_origins` allowlist or a CSP with no `connect-src`. Stack-agnostic (NOT tied to StimulusReflex). Use as a cheap pre-pass before a security review, when auditing websocket code, or to gate these in CI. Emits file:line + the rule + the fix.

Fast, deterministic, no-LLM static checker for the three CSV import footguns that produce NO error in review but bite in production — loading a whole CSV into memory instead of streaming (CSV.read / CSV.parse(File.read) on an import path), missing encoding/BOM handling on file ingest (mojibake, or a BOM that nulls the first header), and create!/save!/update! inside a CSV row loop with no transaction and no per-row error reporting (first bad row aborts the import, no idea which row failed). Scans only import/upload-reachable code (controllers, jobs, services, interactors, models, lib). Use when adding a CI gate for a CSV import feature, or reviewing one for memory blow-up and silent/all-or-nothing imports. This is a CHECKER, not a CSV-writer.

Fast, deterministic, no-LLM checker that asserts a Rails app's N+1 DEFENSES exist (strict_loading config, or a prosopite/bullet/n_plus_one_control gem + test gate) and flags two narrow, high-confidence N+1 anti-patterns — `.count` on an association in a view or loop (a COUNT query per row; use counter_cache + `.size`), and a relation-breaker (`.order`/`.where`/`.pluck`) chained on an association inside a loop (the "includes-ignored" trap that silently defeats an eager-load). This is NOT a general static N+1 detector — Bullet/Prosopite/strict_loading do that at runtime; a grep-based detector is strictly worse. Use as a CI gate or a cheap pre-pass before the runtime gems / dte-perf, to catch the failure-with-no-error (works, tests green, just slow) at rest. Emits file:line + rule + fix.

Deterministically flag layer-boundary violations from palkan's "Layered Design for Rails" — the failures that produce no runtime error but leak request-global state, push queries into the wrong layer, or hide I/O in model callbacks. Use as a cheap, reproducible PRE-PASS before an architectural review, when auditing a Rails app for layering smells, or in CI to gate Current-attributes misuse, request leaks into the domain layer, query-building in controllers/views, and I/O in after_* callbacks. Emits file:line + the rule that fired.

Fast, deterministic, no-LLM static checker that flags test smells which make a Rails test suite flaky, slow, or unable to catch a real bug — `sleep` in feature/system tests, missing WebMock/VCR guard, stubbing the system under test, boolean predicates inside assertions, Mystery Guest setup, and tautological assertions. Reads BOTH Minitest (test/**/*_test.rb) and RSpec (spec/**/*_spec.rb). Use when adding a CI test-quality gate, reviewing a test suite for flakiness/false-greens, or pre-filtering before the dte-test-auditor LLM judge. This is a CHECKER, not a test-writer.

Clean-room mutation testing for Ruby (Prism + stdlib, zero deps). Mutates source one change at a time, runs the suite against each mutant, and reports the mutants tests fail to catch — with a versioned JSON contract and CI/agent gating.

Assisted migration from Pundit, CanCanCan, or Action Policy to current_scope (issue

Creates new Rails 8.1+ applications with full Claude Code integration. Includes Tidewave MCP for runtime Rails integration, Hotwire Club MCP for Hotwire knowledge, and Chrome DevTools for browser automation. Use when asked to "create a new Rails app", "set up a Rails project", or "scaffold a new Rails application".