Ed3Design

@ed3design source repo

64 skills
0 followers
17 hours ago last updated

▌
Cad Construction · ed3design bundle
Use after the design concept is settled (via design-first-iteration or equivalent) and the user is ready to translate it into parametric CAD geometry — component decomposition, parameter hierarchy, construction sequencing. Primary platform Fusion 360; the workflow also applies to SolidWorks, Onshape, FreeCAD, Inventor. Consumes design rules from `mechanical-design-principles`. Trigger on phrases like "now I'm building this in CAD", "create a construction plan", "parameter table for the model", "how do I decompose the project into components", "plan sketches and features". Do NOT load during open design exploration (use `design-first-iteration`), for CAD-automation scripts or parameter-import code (use `cad-api-scripting`), or alone when the user needs design rules (load `mechanical-design-principles` alongside).

0
installs
▌
Cad API Scripting · ed3design
Generate and debug scripting code for CAD system APIs — Python for commercial CAD platforms, OpenSCAD language scripts, and equivalent programmatic modeling interfaces. Load this skill when the user wants to automate CAD construction, generate geometry programmatically, produce parameter-import scripts, or write reusable CAD macros. Trigger on phrases like "write me a Python script for...", "CAD macro", "OpenSCAD file", "parametric script", "API import for parameters", "script to generate geometry". Do NOT load for manual CAD construction guidance (sketch-by-sketch, feature-by-feature) — that is the cad-construction skill. Do NOT load for pure design exploration without code output — that is design-first-iteration. Complements cad-construction: construction defines WHAT to build, this skill handles HOW to build it programmatically.

0
installs
▌
Fusion MCP Bridge · ed3design
Use when driving Fusion 360 from Claude Code through the local MCP-Bridge (HTTP server on 127.0.0.1:7654 with bearer-token auth, single-threaded Custom-Event handler). Covers the API quirks that consistently bite without a documented protocol: component activation before geometry, single-revolve over loft+combine-join, cut-before-shell sequencing, tool-body combine-cut for complex cuts, boolean-union before cuts on multi-body components, bridge timeout/lock recovery, screenshot setup, and the `fusion` CLI that replaces curl boilerplate. Trigger on phrases like "Fusion 360 via MCP", "fusion-mcp-bridge", "Fusion Custom-Event", "run Fusion API script", or any `fusion` CLI command. Do NOT load for general parametric CAD (use `cad-construction`), mechanical-design rules (use `mechanical-design-principles`), or OpenSCAD/FreeCAD (use `cad-api-scripting`).

0
installs
▌
Bom Validation Workflow · ed3design
Use when validating a Bill of Materials (BOM) for a Maker-3D project — an embedded controller project, a speaker/audio build, a smart-home build, or any other physical build with more than 5 components. Trigger on phrases like "check the BOM", "validate the parts list", "review the parts list", "missing components", "reconcile parts inventory", "check hardware stock", "what still needs to be ordered", "check BOM against stock", "audio build BOM", "BOM review". Do NOT load for software dependency lists (use package.json/requirements.txt tooling), for pure schematic checks without physical components, or when the project has only 1-2 components (cost/benefit ratio too low). Encodes the end-to-end-builder pattern: before ordering, check against the hardware stock; do not forget connections + consumables.

0
installs
▌
Image To Mesh Cad Workflow · ed3design
End-to-end workflow for converting a 2D concept image into a parametric 3D CAD model when manual outline tracing is unreliable. Bridges the lossy "image → text-description → manual-spline-points" gap by using AI image-to-3D-mesh services (Tripo3D, Rodin, Meshy) as an intermediate step, then auditing the imported mesh for axis convention + cutout angles + sub-component inclusion before extracting the silhouette and building a parametric Loft/Revolve. Specifically applies to rotationally-symmetric parts (speakers, vases, lampshades, bottles, hubs). Trigger on phrases like "image to 3D mesh", "Tripo3D workflow", "mesh-driven CAD", "extract spline from mesh", "mesh-audit", "Y-up vs Z-up", "cutout position wrong". Do NOT load for normal CAD construction (use `cad-construction`), Fusion-API specifics (use `fusion-mcp-bridge`), or design exploration (use `design-first-iteration`).

0
installs
▌
Mechanical Design Principles · ed3design
Guides mechanical design decisions toward elegant, manufacturable, serviceable solutions with a strong bias toward tool-less assembly, monolithic parts, and form-follows-function. Provides the design rules (the WHAT and WHY — overhang, wall thickness, snap-fit sizing, tolerances, material matching). Load when the user designs mechanical parts, enclosures, housings, brackets, mounts, assemblies, or any 3D-printed component — particularly important for FDM with engineering filaments (ABS, ASA, PC, PA-CF, PETG-CF). Trigger on phrases like "design a housing", "build an enclosure", "how should I mount", "I'm designing a part", "3D print", snap-fit/press-fit questions. Do NOT load alone for iterative design conversations (load `design-first-iteration` alongside), for CAD workflow / parameter tables (use `cad-construction`), or for CAD-automation code (use `cad-api-scripting`).

0
installs
▌
Embedded UI Svg Doc From Source · ed3design
Use when documenting an embedded device GUI (ESP32/Arduino touchscreens, LovyanGFX/TFT_eSPI/U8g2/LVGL screens) for end-user instructions, printable manuals, or design reviews — and the source code already contains the drawing calls (`gfx.fillRect`, `gfx.drawString`, `gfx.drawLine`, `tft.drawPixel`, `display.print`, LVGL-styles etc.). Trigger on phrases like "user manual for the display", "manual with mockups", "UI documentation for the ESP32 device", "printable manual for embedded UI", "screen mockups for the touchscreen", "display screenshots without hardware", "1:1 SVG from the source code", "tangible mockup". Do NOT load for web-frontend UI docs (use frontend-design or marketing), for CAD assembly drawings (use cad-construction), or when no source code with literal draw coordinates exists. This skill encodes the "measure, don't estimate" maxim (originally CAD) applied to embedded-UI documentation: translate the draw calls verbatim into SVG, do not rebuild semantically.

0
installs
▌
Victron Cerbo Modbus Device Onboarding · ed3design
Use when a new Victron Modbus-TCP device (EV Charging Station, energy meter, inverter) is connected to the Cerbo GX LAN but does not appear in the Cerbo UI or D-Bus, despite being reachable via ping. Trigger on phrases like "EVCS not visible in Cerbo", "new Modbus device does not appear", "Cerbo does not detect wallbox", "dbus-modbus-client does not find device", "Victron device not showing in GX", "Cerbo Device List empty even though device is on the network". Do NOT load for VE.Can/VE.Bus devices (different bus protocol), for Cerbo-Setup-from-scratch (different skill scope), or for VRM cloud connectivity problems.

0
installs
▌
Vault Search Helper · ed3design
Use when the user names a topic/project/object and you must do a Vault-First search for existing notes (mandatory pattern: "Vault-First — required for every named topic"). A single call to `${CLAUDE_PLUGIN_ROOT:-$HOME/.claude}/tools/vault-search.py` replaces 2-3 Glob+Grep calls and returns ranked top-N notes with wikilink + score breakdown + excerpts. Trigger on phrases like "Vault-First", "where in vault", "find note", "existing on this", "check inventory", "is there already something", "search vault". Do NOT load for known-path file reads (use `Read` directly), for pure filename searches (use `Glob`), for external-system searches (LaunchAgents, remote server — use `ls` and `ssh`), or when the user explicitly requests a multi-pass search.

0
installs
▌
Pytest Venv First Triage · ed3design
Use when pytest shows multiple failures or errors (especially ModuleNotFoundError clusters) and you're about to dig into individual test fixes. ALWAYS check the Python environment FIRST — `which python3` vs `venv/bin/python3` — before debugging individual tests. System-Python frequently lacks project deps (cachetools, asyncpg, etc.) while project venv has them. Trigger on phrases like "pytest shows many failures", "test errors after pull", "these tests were green yesterday", "ModuleNotFoundError multiple files", "pre-existing failures", "tests broken without code change", "ImportError test sweep". Do NOT load for single-test-fail debugging (use systematic-debugging directly), for Python projects without venv (no env mismatch possible), or for failures with clear test-logic bugs (e. g. assertion errors with concrete values).

0
installs
▌
Code Review Chunk Dispatch · ed3design
Use when the code-review-backlog is large (>30 commits OR >5,000 LoC changed since last review) AND the caller has Agent/Task-tool dispatch capability (.e., top-level orchestrator or main Claude session). Trigger on phrases like "code-review backlog is big", "no review for weeks", "many commits without review", "review of 100+ commits", "how do I review these 200 commits", "chunk review", "parallel code-reviewer subagents". Do NOT load for single-PR review (use superpowers:requesting-code-review directly), for <30-commit backlog (single subagent suffices), for non-Git codebases (chunking-by-SHA-range presumes git workflow), or when running as a subagent yourself without Agent-tool access (the chunk-dispatch pattern is then unexecutable — use risk-based-triage instead, documented in the skill's Fallback section). Complements (sub-of) `superpowers:requesting-code-review` and `superpowers:dispatching-parallel-agents`.

0
installs
▌
Ga Skill Edit Tdd Workflow · ed3design
Use when editing or expanding an already-GA-promoted skill (suffix-less name, banner says PROMOTED) to add a new capability/class/feature. Different from `skill-tdd-promotion-workflow` which covers DRAFT→GA. This skill covers GA→GA+Capability — the failure mode is silent-rename-or-expand without RED-test for the new capability (Iron-Law violation). Trigger on phrases like "extend skill with X", "add a new class to an existing skill", "extend asyncpg-skill with JSONB", "rename GA skill + extend capability", "skill rename with content expansion", "Cycle-2 capability for promoted skill". Do NOT load for new skill from scratch (`superpowers:writing-skills`), for DRAFT→GA promotion (`skill-tdd-promotion-workflow`), for minor edit without new capability (just edit), or when the target skill doesn't exist.

0
installs
▌
Image Preprocessing Helper · ed3design
Use when about to send an image to Claude Vision API (PNG/JPG screenshots, iPhone photos, BOM photos, hardware screenshots, design mockups, large web screenshots). Pre-process locally with `${CLAUDE_PLUGIN_ROOT:-$HOME/.claude}/tools/img-preprocess.py` to reduce Vision token costs by 75-92%. Trigger on phrases like "look at this screenshot", "analyze photo", "read image", "OCR from the image", "what does this image show", "check dashboard screenshot". Do NOT load for tiny images already <1024×1024 (no saving), for images the user explicitly says to leave untouched, or for non-visual analyses (file metadata via `Read` is enough).

0
installs
▌
Pre Push Bypass Audit Trail · ed3design
Use when a `git push` is blocked by a pre-push hook (freshness/lint/test/data-pipeline) AND the blocking condition is provably orthogonal to the commits being pushed (different subsystem, different pipeline, known pre-existing issue). Trigger on phrases like "pre-push hook blocks", "--no-verify with justification", "hook drift", "freshness check failed", "push aborted but code is OK", "should use --no-verify". Produces (1) orthogonality check before bypass, (2) audit-trail entry in the Daily Note with reason + blocking issue + backlog reference, (3) a separate backlog item for the blocking issue, (4) the `--no-verify` push only after these are done. Do NOT load when the hook block is directly related to the commits, when no Daily Note exists, when bypass has not been explicitly approved by the user, or when the blocking issue is critical/security.

0
installs
▌
Design First Iteration · ed3design
Use to support iterative design work where the user wants to develop principles and solutions before committing to final dimensions or details. This skill takes precedence over domain-specific skills (mechanical-design-principles, cad-construction, engineering-web, cad-api-scripting) in multi-turn design conversations — load it alongside the relevant domain skill, not instead. This skill provides the conversation framework (how to ask, how to iterate, when to verify); the domain skill provides content rules. Trigger on phrases like "let's design", "I'm working on a design", "help me think through this", "explore options", "what if", "design-first approach", or when the user provides photos, sketches, or partial specifications. Read the full skill content when loading — the pre-design checklist and later principles matter as much as the core philosophy. Prevents premature dimensioning, document drift, and geometry-before-orientation errors.

0
installs
▌
Asyncpg Live Vs Mock Shape · ed3design
Use when writing pytest mocks for asyncpg-backed endpoints where the column type causes mock-vs-live divergence (SUM/COUNT/AVG → Decimal; JSONB → str; UUID → UUID-object; INET → str). asyncpg returns raw PG-types that don't match naive intuition — mocks with the "natural" dict/int/float pass shape-tests but the real DB-call fails live. Trigger on phrases like "asyncpg mock test", "asyncpg JSONB mock", "asyncpg returns string for JSONB", "TypeError Decimal float", "AttributeError str object no attribute keys", "mock-and-live diverge for asyncpg". Do NOT load for psycopg-2-based tests (different driver, auto-coerces JSONB), for SQLAlchemy ORM tests (the ORM coerces types), or for asyncpg connections with `set_type_codec('jsonb', ...)` registered (the codec handles conversion).

0
installs
▌
Post Session Skill Review · ed3design
Use at the end of any productive session, when writing a Daily Note, when the user says "wrap up" / "remember" / "session done", or proactively after observing repeated workflow patterns within a session. Trigger on phrases like "end of session", "let's wrap up", "end of day", "session wrap-up", "end of day review", "what did Claude learn today", "is there a skill in here?", "post-session review", "skill candidate review". Do NOT load mid-session for active task work, for single-task sessions with nothing repeatable, or when the user is in mid-debug (they need closure, not meta-reflection).

0
installs
▌
Commit Message Honesty Precheck · ed3design
Use before writing or finalizing a git commit message, especially when the subject line uses words like "NO-OP fix", "no behavior change", "refactor only", "trivial", "cleanup", "minor", "simple bump", "doc-only" — these phrases are often LIES in disguise that hide real semantic changes. Trigger on phrases like "small fix", "just a refactor", "NO-OP", "behavior unchanged", "trivial change", "harmless cleanup", "just bumping the default", or before any commit that touches a default value, signature, env-var fallback, or filter parameter. Do NOT load for genuinely cosmetic changes (typos, comments-only, whitespace), for first-line spelling, or for non-git contexts (slack messages, jira tickets).

0
installs
▌
Cross File Source Of Truth Grep · ed3design
Use when about to refactor a value, constant, helper-function, lookup, or config-pattern from old-form to new-form across the codebase — schema-drift fixes, display-name SoT migration, config-pattern updates (hardcoded ID → env-var), helper rename, deprecated-import cleanup. STOP and run `grep -r "<old-pattern>"` on the WHOLE repo BEFORE writing the new pattern anywhere. Trigger when phrases like "I'm refactoring X to Y", "fix schema drift", "migrate from old to new form", "rename helper", "single-source-of-truth" appear, OR a mental model of "only 3 files use this" exists — dispatcher, scheduler, jobs, notifications, tests often hide additional places. Method: `grep -rn "<old-pattern>" --include="*.py"` excluding cache dirs, then categorize each hit. Do NOT load for greenfield code, pure-cosmetic renames in same file, or refactors guaranteed file-local.

0
installs
▌
Pre Deploy Code Drift Detection · ed3design
Use when about to deploy a service that has multiple parallel push-sources (Mac + work-laptop + server-direct-edit + remote Claude session), to detect 3-way Git-drift between local, origin/main, and server-checkout BEFORE rsync/checkout/build destroys parallel work. Trigger on phrases like "deploy to server", "rsync to server", "server has working-tree changes", "why does origin have commits I don't have", "Mac + server-direct-edit drift", "code drift between machines". Do NOT load for first-time-setup-deploy (no parallel sources yet exist), for single-developer-single-machine workflows, for server-only-via-CI deploys (CI is the sole push-source), or for in-container-hot-reload-iteration (no rsync involved). This skill encodes a hard-won lesson: 4h lost because 15 server-commits were made before discovering that origin/main had parallel local commits (3-source drift between local, origin, and server). A 2-minute pre-flight would have prevented it.

0
installs
▌
PDF Text Extract Without Vision · ed3design
Use BEFORE reading any PDF file when the goal is to extract textual content (specs, contracts, articles, manuals, financial reports, legal documents). STOP and run `pdftotext` from poppler-utils locally instead of letting Claude read the PDF directly. Claude Vision burns 1-5k tokens per page even for text-heavy PDFs that are 100% mechanically extractable. `pdftotext` is a free local CLI (typically at /opt/homebrew/bin/pdftotext) that converts the PDF text-layer to plain UTF-8 at zero token cost. Trigger on phrases like "read this PDF", "extract text from PDF", "what's in the PDF", "summarize the PDF", "analyze PDF", "read spec from PDF", "evaluate contract from PDF", any user request involving "PDF" + content comprehension. Do NOT use for image-only PDFs without OCR'd text layer (fall back to Vision or run `ocrmypdf` first), PDFs where layout is the primary information (drawings, mockups, infographics), PDFs less than ~1 page, or PDFs with critical embedded images.

0
installs
▌
Code Review Backlog Cost Warning · ed3design
Use when the user/agent is about to push code, merge a feature branch, or claim work as "done" AND no code-review has happened recently. Specifically trigger when ANY hold: >7 days since last `requesting-code-review` invocation, >30 atomic commits accumulated since last review, >5000 LoC changed, pre-push-hook code-review-warning bypassed ≥2 times in succession, or the user says "haven't done a review in weeks", "I'll just push this", "the hook is only a warning, ignore it", "it's just a small fix on top". STOP and surface a cost-estimate-warning BEFORE the push — quantify expected backlog cost (wallclock + tokens + re-review cycles) and offer chunked-parallel-review-dispatch as alternative. Do NOT load for fresh branches (≤3 commits, ≤500 LoC, ≤2 days), explicitly-marked WIP pushes, inside an active review session, or one-line typo/doc commits.

0
installs
▌
Silent Except Hides Schema Drift · ed3design
Use when reviewing or writing Python code with `try`/`except Exception:` clauses around SQL queries (asyncpg, psycopg2, sqlalchemy, sqlite3) where the except-branch either (a) silently returns an empty collection (`signals = []`, `rows = {}`, `data = None`), (b) re-renders the UI with empty state ("No active signals", "No data today"), or (c) catches with a bare/overly-broad type — without `logger.exception()` or re-raise. Danger: a schema-drift bug (column does not exist, FK-target-rename, ORM-out-of-sync) and a legitimate empty-result look IDENTICAL to the user. A dashboard panel saying "No signals today" silently means EITHER no signals OR the SQL crashed and was swallowed. Trigger phrases like "dashboard shows empty but DB has data", "except Exception: signals = []", "dashboard card permanently empty", "code swallows DB error". Do NOT load for non-DB silent-except, catch-and-re-raise patterns, or narrow except-clauses that log.

0
installs
▌
Bash Output Filtering Disciplines · ed3design
Use BEFORE running any Bash command that could produce more than ~50 lines of stdout: `docker logs`, `docker ps -a`, `git log`, `find`, `ps aux`, `psql -c "SELECT * FROM..."`, `cat large.log`, `ls -la` deep dirs, `journalctl`, `dmesg`, `kubectl logs`, `du -a`. STOP and apply head/tail/grep/wc/jq/awk/sed pre-filters in the same pipeline — never let raw output flow into the conversation context. Every line above the relevant data is wasted tokens; a single morning session can burn ~50k tokens on container status alone. Trigger on phrases like "docker logs of container X", "look at git log", "ps aux", "journalctl", "SELECT * FROM table", "why is the session token consumption high". Do NOT apply when the user explicitly asked for full output, for inherently small commands (`whoami`, `pwd`, `date`), one-shot value-extractions, or when piping to a file.

0
installs
▌
Skill Tdd Promotion Workflow · ed3design
Use when promoting an existing DRAFT/STUB skill (suffix `-DRAFT` or `-STUB` in `name:` field, OR description starts with "STUB —") to GA (auto-discoverable). Different from `superpowers:writing-skills` which covers CREATE-from-scratch — this skill covers the LIFECYCLE-STAGE from "skeleton-exists" to "production-ready". Requires Agent/Task-tool for parallel RED+GREEN subagent-Dispatch (Step 3) — if the caller does NOT have Agent-tool (e.g. running as a general-purpose-subagent themselves), STOP and report-up; do NOT silently fall back to name-rename-only. Trigger on phrases like "promote this DRAFT skill", "TDD for the remaining STUBs", "make it auto-discoverable", "skill promotion cycle", "release skill from -DRAFT", "TDD promotion cycle for N skills". Do NOT load for creating a new skill from scratch (use `superpowers:writing-skills`), for editing GA-skills (just edit), when no DRAFT/STUB-suffix exists (skill is already GA), or when target skill file does not exist (no work to do).

0
installs
▌
Code Review Findings Als Red Tests · ed3design
Use when a code-review subagent (e.g. feature-dev:code-reviewer) has returned Critical/Important findings on a feature commit and you're about to write fixes. Standard default is "direct-fix, no new test". This skill says: each finding is itself a test case — write a RED test that shows the bug behavior, then GREEN fix. Prevents regressions + documents the bug pattern for future reviews. Trigger on phrases like "fix code-review findings", "implement Critical fix", "review subagent found C1/I1/I2", "convert reviewer output to fix", "close review cycle". Do NOT load for trivial style findings (typo, unused-import), for findings without a reproducible code path (perf hints, future-proofing), for code where TDD was consciously skipped (user-confirmed), or when the subagent had NO findings.

0
installs
▌
MCP Server Stdio To HTTP Migration · ed3design
Use when an MCP server uses `stdio` transport AND is spawned per-sub-agent via `uvx --from git+https://...`, `npx git+https://...`, or an equivalent on-demand-installer, AND you observe ANY of: (a) `.in_use/` lock-directories accumulating as zombies, (b) 10+ second startup per sub-agent (uvx re-resolves the Git source), (c) one server process per sub-agent instead of a shared instance, (d) the server "hangs" at session start. Fix-pattern: migrate to `streamable-http`/`http` transport with a persistent server (macOS LaunchAgent or systemd-unit) on a fixed localhost port, and point the client config at the HTTP URL. Result: one shared process, no zombies, startup O(seconds)→O(milliseconds). Trigger on phrases like "MCP zombie processes", "MCP stdio slow startup", "uvx --from git is slow", "streamable-http LaunchAgent". Do NOT load for servers designed for short-lived stdio (file-system MCP), for non-Git pip-installed servers that already start fast, for first-time MCP setup, or for server-selection questions.

0
installs
▌
Remote Script Scp Over Ssh Heredoc · ed3design
Use when writing or deploying scripts to a remote server via SSH and the script contains special characters (backticks, $, quotes, heredocs) that break SSH string quoting. Trigger on phrases like "SSH heredoc fails", "quoting hell in SSH", "backtick in remote script", "unexpected EOF on SSH", "tee over SSH doesn't work", "remote script with special characters", "scp instead of SSH heredoc", "SSH string broken". Do NOT load for simple single-line SSH commands without special characters, for Ansible/Fabric (their own templating mechanisms), or for local scripts.

0
installs
▌
Ephemeral Container File Detection · ed3design
Use when designing or auditing Docker-based deployments BEFORE writing implementation plans that rely on files persisting across container rebuilds. Trigger on phrases like "volume mount for X", "why are the files gone", "container rebuild deleted the models", "model_path points to a file that's not there", "phantom registry in DB", "inference fails with FileNotFoundError", "before Claude build — are the prerequisites in place", "pre-flight deployment audit", "writing-plans for a Docker feature with persistent data". Detection-Pattern in 4 steps: docker inspect Mounts → ls container dir → stat birth-time → grep dump/save calls in code → if code writes but the mount list does NOT include the path → ephemeral, pre-flight STOP for the feature phase. Do NOT load for non-Docker deployments (systemd services, Kubernetes StatefulSets — different model), for read-only containers without write paths, for single-file apps without a storage layer. The maxim "read logs/code/DB first" applied to deployment prerequisites.

0
installs
▌
Subprocess Ssh Arg Quoting Via Shlex · ed3design
Use BEFORE writing or debugging Python `subprocess.run(["ssh", host, "cmd", "arg1", "arg2"])` calls where remote args contain shell-metacharacters — pipes `|`, parens `()`, semicolons `;`, dollar-signs `$`, backticks, quotes, glob `*?`, tabs `\t`, or empty strings. The naive list passed after host is silently joined by SSH with spaces and re-evaluated by the REMOTE shell. Symptoms: 'syntax error: unexpected end of file', 'option requires an argument', 'command not found', or silently-wrong arg parsing. STOP and use `shlex.quote()` on EACH remote-side arg, then `' '.join(quoted_args)` to produce ONE string passed as a SINGLE post-host arg. Trigger on phrases like "ssh + docker exec doesn't work", "psql via SSH gives syntax error", "MCP server SSH tunnel", "Bash syntax error from remote", "tab character disappears in SSH". Do NOT use for `shell=True` calls, SSH config aliases without metacharacter-args, pure tunnel/SFTP, or pure-local subprocess.

0
installs
▌
Brain Dump To Phased Roadmap · ed3design
Use when the user presents a loose collection of items (a brain-dump, an inbox-list, a "I want to do all of these" list, scattered TODOs) and wants help turning it into an actionable plan — phases with dependencies, entry triggers, and confirmation questions on each meaningful design decision. Trigger on phrases like "I have a few things here", "clean up the brain-dump", "how do I tackle all this", "roadmap from these items", "consolidate the inbox", "I don't know where to start", "make me a plan out of this", "consolidate this list into a plan", "turn this dump into a roadmap". Do NOT load when the user already has a phase plan and wants to execute it (use gsd:gsd-execute-phase), when there is a single concrete task (just do it), or for design exploration where the items are not yet committed work (use design-first-iteration). Complements gsd:gsd-new-milestone and gsd:gsd-plan-phase — this skill bridges the gap *before* either of those, when items are still unstructured and clusters are not yet visible.

0
installs
▌
Pre Migration Data Verification · ed3design
Use before adding a constraint to an existing populated table (CREATE UNIQUE INDEX, ALTER ... ADD CHECK, ALTER ... NOT NULL, ADD FOREIGN KEY): query the existing data for would-be violations FIRST and write a cleanup-statement (UPDATE/DELETE) into the same migration block BEFORE the constraint-create. Skipping this → silent migration failure ("duplicate key" / "check violation" / "null value not allowed"), the entire migration rolls back and no error surfaces until the next deploy. Trigger on phrases like "add unique constraint to existing table", "CREATE UNIQUE INDEX migration", "ALTER TABLE ADD CHECK", "make column NOT NULL on existing data", "add foreign key to populated table", "migration silently failed". Do NOT load for first-time CREATE TABLE migrations (no existing data to violate), for column ADD migrations without constraints (defaults handle the gap), or for development DBs that can be wiped. PostgreSQL-focused; the pattern transfers to MySQL/SQLite/Oracle.

0
installs
▌
Async Context Manager Retry Pattern · ed3design
Use when implementing retry-logic around an `async with X:` block where `X.__aenter__()` or `X.__aexit__()` performs network-IO that can fail transiently (python-telegram-bot, asyncpg pools, httpx, websockets). Iron-Law: every `async with` whose enter/exit does network-IO must sit INSIDE the retry-loop, not around it — otherwise enter-failures bypass the inner `try/except` and get caught as "Unexpected" with zero retries actually attempted. Trigger on phrases like "retry around async with", "TimedOut from __aenter__", "I implemented retry but it doesn't trigger", "context manager exception bypasses retry". Do NOT load for sync context-managers, async-with where __aenter__ does only local work (file-open, in-memory state), retry around async-iterators, or first-time-design of an async-context-manager class itself.

0
installs
▌
Aggregate Code Review After Tdd Tasks · ed3design
Use when implementing a multi-task TDD plan via `superpowers:subagent-driven-development` AND all individual tasks have already passed their per-task two-stage review. Per-task reviews check one commit against one task — they cannot catch cross-commit drift that only appears when reading the full feature end-to-end. Triggers a final aggregate review looking for: state-machine/algorithm-order drift between spec and code, naming-inconsistency across commits, end-to-end data-flow integrity, commit-message honesty, pre-commit-hook coverage gaps (lazy imports), test-suite cohesion. Trigger phrases like "Tasks 1-N all done", "aggregate review before live-run", "cross-commit drift check", "verify end-to-end behavior against spec". Do NOT load for single-commit reviews, per-task reviews within SDD, branches with <3 atomic feature-commits, or hotfixes without spec-text target.

0
installs
▌
Static Source Bug Class Coverage Test · ed3design
Use when adding regression-test coverage for a bug-class that manifests as a repeated source-code pattern across multiple call-sites in the same file or codebase, NOT a single localized bug. Pattern: write a static-source-inspect-test that reads the source file directly via `Path(__file__).resolve().parents[N] / "src/file.py"`, extracts pattern candidates via regex (e.g. all triple-quoted SQL blocks containing certain tokens), and asserts each candidate contains the fix-marker. Critical: include a whitelist-skip for f-string templates with externalized variables that receive the fix at their definition site. Trigger on phrases like "write bug-class coverage test", "static source inspect test", "regression guard for the same bug pattern in multiple call-sites", "why not just endpoint mocks for all 4 spots?". Do NOT load for single-call-site bugs, bug classes not recognizable in the source pattern, or files with complex multi-layer f-string nesting where false-positive whitelisting becomes unreliable.

0
installs
▌
Briefing Source Triangulation · ed3design
Use when building a status briefing (morning standup, weekly review, "where was ", session-start briefing) that reads from multiple persistence sources (Daily Note + `.remember/today-*.md` + `.remember/recent.md` + git-log + file mtimes). Without conscious source-priority, briefings can claim items as "open" that were actually completed (e.g. email sent, meeting held, file shipped) because secondary sources lag or summarise. Trigger on phrases like "morning briefing", "daily standup", "where was ", "what was still open", "session-start briefing", "weekly review", "monthly close", "what's new since yesterday", "day overview", or any skill invocation that consumes `.remember/today-*.md` or `recent.md` as status input. Do NOT load when only consuming a single source (just reading the Daily Note for context), when writing INTO `. remember/` files (those are plugin-owned, not briefing input), or for code-only context-gathering (use git-log directly)

0
installs
▌
Enum Known Values Via Insert Grep · ed3design
Use BEFORE writing or editing a Python-side constants/enum/validator-set that should match a DB-column's real value-space — `_KNOWN_X = {...}`, `VALID_<DIMENSION> = frozenset(...)`, `class XStatus(str, Enum)`, `pydantic.Field(..., regex='^(a|b|c)$')`, in-app filter-allowlists. STOP and grep ALL `INSERT INTO <table>` + ALL `<table>.<column> = ...` setter-lines + ALL UPDATE-statements that touch the column BEFORE deciding the value-set in Python. Trigger when phrases like "maintain the _KNOWN_SOURCES list", "define valid_phase_set", "build pydantic validator for column", "filter-allowlist for UI", "value X is silently accepted", "value Y is wrongly rejected" appear. Method: grep INSERT/setter/UPDATE → verify actual values → disambiguate table/column/mode-field. Do NOT load for greenfield-tables (no INSERTs exist yet), typed-Postgres-ENUMs (`\d` shows the list), or purely internal Python constants without DB context.

0
installs
▌
Read Only SQL Via Regex Validator · ed3design
Use when exposing a read-only SQL endpoint to a less-trusted caller (browser via HTTP, MCP-Tool to LLM, internal dashboard with copy-paste query box, future API consumer). The endpoint accepts a SQL string and must reject all mutating statements before executing. Encodes the regex-based denylist+allowlist pattern: (1) strip SQL comments (`--` and `/* */`) BEFORE matching to prevent comment-smuggle bypass, (2) normalize whitespace + uppercase, (3) denylist regex for INSERT/UPDATE/DELETE/DROP/CREATE/ALTER/TRUNCATE/CALL, (4) allowlist regex for SELECT/WITH/EXPLAIN/ANALYZE start-tokens. Trigger phrases like "read-only SQL endpoint", "SELECT-only API", "SQL escape hatch", "DB query as HTTP endpoint", "MCP tool exposes raw SQL", "Postgres read API". Do NOT load when a real SQL parser is available (sqlparse, pglast), for write-allowed endpoints, stored-procedure invocation, or DBs where SELECT itself has side-effects.

0
installs
▌
Decision Plan Hypothesis Matrix · ed3design
Use BEFORE implementing a non-trivial decision-driven task where multiple outcomes are plausible — backtest planning, algorithm comparison, architecture choice, migration strategy, "should build X or not". Trigger on phrases like "should build X", "plan a backtest", "I need a decision", "test algo variants", "how do I measure success", "max-effort session", "choose refactoring strategy", "define Compound-GO". Produces a Plan-Note with explicit Hypothesis-Matrix (each H + counter-thesis + Distinguishing Metric), Compound-GO-Logic, Out-of-Scope, and Done-Definition. Do NOT load for single-path implementations with no decision ("fix this typo"), brainstorming/exploration phase (use `superpowers:brainstorming` first), plans without binary GO/NO-GO outcome (use `superpowers:writing-plans`), or tasks without a measurable success criterion.

0
installs
▌
Production Seed Vs Demo Seed Split · ed3design
Use when about to push a Code-Repo with seed/fixture-data containing real personal/customer/tenant data to a Remote (GitHub, GitLab) — even private. Triggers on phrases like "push repo for the first time", "create new private repo", "set up GitHub remote for <project>", "commit seed.py", "tenant data in code", "customer data in test data", "GDPR test data". Do NOT load for repos without personal data (pure tech repos like ESP32-firmware), for already-pushed repos (then it's git-filter-repo territory, different skill), or for ephemeral test-data without real-person reference. Encodes a property-management push-session pattern: 26 commits contained real tenant data + a .env demo credential; without the pre-push scan everything would have landed on GitHub.

0
installs
▌
Schema Use Case Mismatch Detection · ed3design
Use when a user reports "field X is always NULL in table Y despite active code" or "data missing from a table that's actively being written to" — BEFORE jumping to "fix the bug, set the field". Iron-Law: when a single DB-table has ≥2 writer-paths with different semantics (per-trade vs per-portfolio, legacy vs new pipeline), the field-NULL-symptom is often NOT a bug but a schema-use-case-mismatch — the active writer simply lacks the semantics to produce that field. A "fix" without this check would patch the writer to set a value that doesn't exist semantically. Trigger on phrases like "verdict is always NULL", "field X always missing", "this column is never populated", "INSERT list incomplete", "data not appearing despite job running", "two write-paths same table different semantics". Do NOT load for ALTER-TABLE-missing-column, permission issues, connection issues, or first-implementation of a feature.

0
installs
▌
Frontend UI Self Verify Before User Demo · ed3design
Use when a frontend/UI change has been deployed (Vite/React/Vue, FastAPI Jinja, Electron, any browser-rendered surface) AND you are about to tell the user "refresh the browser", "check the app", "it's deployed" — STOP and self-verify first via Playwright/Chrome-DevTools-MCP: `browser_navigate` → `browser_snapshot` → `browser_take_screenshot` → `browser_evaluate` (DOM-query the element/text/style you changed). Especially required when (a) the surface has multiple modes (edit/preview/print, light/dark, mobile/desktop) and the user may view a different one than you changed, (b) the user already complained "nothing changed" — switch to verify-mode, do NOT add cache-busting theories, (c) you rebuilt >2 times without visual confirmation. Do NOT load for backend-only changes, for changes the user said to deploy without checking, or for features needing auth/state a headless browser cannot reach. Prevents burning debug-rounds on cache-theories when the change rendered in a mode the user wasn't looking at.

0
installs
▌
Compound Gate Over Single Metric · ed3design
Use when designing or reviewing a Go/No-Go-Gate, Backtest-Acceptance-Threshold, ML-Model-Promotion-Criterion, A/B-Test-Verdict, or any binary decision-rule that triggers a downstream action (deploy, promote, ship, reject) based on a single metric — especially WR/Accuracy/Recall/F1/CTR. Single-metric gates have a documented failure mode: false-positive accepts where the system clears the gate while a hidden dimension regresses catastrophically. Compound-Gate (≥2 metrics with AND-conjunction) closes this hole. Trigger phrases like "WR-Gate-Verdict", "Backtest-Go-No-Go", "Accuracy-Threshold", "Model-Promotion-Criterion", "A/B-Verdict-Rule", "single-metric acceptance". Do NOT load for domains where single-metric meaningfulness is established (medical-sensitivity for binary screening, latency-SLO), theoretical discussions without downstream consequence, or metrics that already trade off two dimensions (F1).

0
installs
▌
Domain Rules Anti Patterns First · ed3design
Use when modeling a domain that has formal legal/regulatory rules — pensions, taxes, insurance, employment law, inheritance law, social law, healthcare law, unemployment benefits/social benefits, contract law, civil code, tax code, social code, etc. Trigger on phrases like "calculate pension", "model tax", "insurance contribution", "entitlement to X", "qualifying period", "assessment basis", "retirement age", "deduction", "inheritance", "gift tax", "unemployment benefits", "old-age pension", "survivor's pension", "benefits suspension period", "one-fifth rule", "progression clause", "tax form V", "advertising costs", "special expenses", "allowance", "contribution assessment limit". Do NOT load for general programming domain modeling (database schemas, API contracts), for pure math/physics modeling (no legal/regulatory aspect), or for project-internal business logic where you are the rule-author.

0
installs
▌
Asyncio Fire And Forget Loop Exit Await · ed3design
Use when writing or reviewing Python code that uses `asyncio.run(...)` as entry-point AND inside the entry-coroutine uses `asyncio.create_task(...)` for fire-and-forget background work (notifications, telemetry, advisor-calls, fan-out HTTP/DB-writes). Without an explicit `await asyncio.gather(*pending_tasks)` before the entry-coroutine returns, `asyncio.run()` closes the event-loop and CANCELS still-pending tasks — silent data-loss of 0-50% of background work. Trigger on phrases like "asyncio.run + create_task", "fire-and-forget cancelled at loop-exit", "telemetry silent dropping", "Loop closed before task finished". Do NOT load for asyncio.Runner / gather-as-entry patterns, long-running daemons (uvicorn, asyncio.Event.wait), sync code with threading.Thread, or non-Python async (JS/Go).

0
installs
▌
Cross Repo State Inspection Before Commit · ed3design
Use when the user issues a vague git instruction like "commit hub", "push that to the repo", "should go in git", "put that under version control", "stage the changes", "deploy that to GitHub" — without specifying scope (which files, which repo, which branch, push-or-just-commit, new-repo-or-existing). Jumping to action without verifying repo state risks picking the wrong scope: committing everything when only one subdir was meant, creating a new repo when one already exists, pushing modifications meant to be deferred. The agent must run `git status` + `git log origin/main..HEAD` + `git remote -v` before acting. Trigger phrases like "commit X", "push that", "into the repo", "into git", "stage that", "bring to GitHub", "new commit needed". Do NOT load when the user has given fully-specified instructions, for clearly-single-project repos, when the working tree is clean, or for fresh `git init` workflows.

0
installs
▌
Lazy Module Getattr For Settings Override · ed3design
Use when a Python app needs user-editable runtime configuration that should OVERRIDE existing code constants without refactoring downstream callers. Triggers on phrases like "build settings form", "user should be able to change values", "without refactoring calc.py", "DB override above defaults", "inputs.py stays, but DB should take precedence", "how to make the hardcoded values editable". Do NOT load for greenfield apps without existing code constants (then settings class from the start), for performance-critical hot paths where module-`__getattr__` would be a bottleneck, or when the values already go through dependency-injection (then refactor is minimal). Pattern: `inputs.py` remains as defaults, new `cfg.py` with module-level `__getattr__` (PEP 562) does lazy lookup to settings DB with 60s TTL cache, fallback to inputs.py. Callers import `from data import cfg as inputs` (1-line change) — calc.py + other consumers stay unchanged

0
installs
▌
Schema Verify Via Information Schema · ed3design
Use when about to write or execute SQL against a PostgreSQL/TimescaleDB table whose exact schema (column names, types, deprecated-vs-active-variant) is not 100% certain from current context — especially in forensic debugging where multiple tables have similar names (`ohlcv_1d` vs `ohlcv_1d_hist`, `users` vs `users_v2`) or column names have shifted over time. Iron-Law: `SELECT column_name, data_type FROM information_schema.columns WHERE table_name=$1 ORDER BY ordinal_position` is the cheapest 30-second insurance against UndefinedColumn, false-positive-empty-result, and wrong-table-queried. Trigger on phrases like "writing a query against table X", "UndefinedColumn", "column X does not exist", "verify DB schema", "I think the column is called Y", "before any forensic query". Do NOT load for ORM-mediated queries (SQLAlchemy/Django catch drift at model-load), first-time-schema-design, catalog-queries on information_schema itself, or connection issues.

0
installs
▌
Forensic Trail For Fire And Forget Sends · ed3design
Use when designing or hardening any "send + log + swallow" pattern (Telegram bot sends, email notifications, webhook dispatches, Slack pings, push notifications, SMS sends) where DB-state persistence is separated from external API send, send-errors fail-open via log-only, and future forensics may need to distinguish "send happened, user missed" from "send never happened" without relying on log-aggregator availability. Trigger on phrases like "log.warning on send-fail", "fire-and-forget Telegram", "why didn't the notification arrive", "DB save ran but Telegram didn't", "container logs are gone", "*_sent_at column". Produces (1) DB migration for `*_sent_at TIMESTAMPTZ`, (2) update-after-send-OK persistence, (3) forensic query template. Do NOT load for synchronous send-and-wait patterns, sends with guaranteed-persistent external log aggregation, or one-off ad-hoc scripts.

0
installs
▌
External Advisor Output Plausibility Audit · ed3design
Use when an externally-commissioned advisor output (energy-consultant roadmap/iSFP, PV quote, renovation quote, tax-advisor note, expert report, investment recommendation) needs evaluation — do NOT accept the numbers at face value, run a structured 5-step audit: (1) inventory reality-check, (2) sequence/legal-check against applicable law, (3) cost/market-check against realistic values, (4) completeness-check (implied-but-not-costed components), (5) motive-check (advisor incentives, double application, kickback risk). In one real case this surfaced 6 technical defects plus an apparent subsidy-fraud construct. Trigger on phrases like "review this iSFP", "run the numbers on this quote", "the tax advisor says", "how should I evaluate this offer", "should I adopt this proposal". Do NOT load for the user's own data analysis, for pure market research (no concrete offer), or for legally-mandated expert reports (structural engineer, chimney sweep — a different audit mode).

0
installs
▌
Plan Execution Stack Mode Precheck · ed3design
Use as Pre-Step-0 of `executing-plans` / `subagent-driven-development` / inline-plan-execution when the plan contains `docker compose exec`, SSH commands or other stack-interaction steps. The check distinguishes (a) local-runnable-stack vs (b) remote-only-stack vs (c) hybrid-mode (code-local + live-remote). Prevents mid-execution stop-gates when the plan implicitly assumes "docker compose works here" but secrets/.env.prod, env-files, or services are missing locally. Trigger on phrases like "execute the plan", "executing the plan", "subagent-driven execution start", "docker compose exec in plan steps", "deploy stack vs dev stack", "your-server vs local" mid-plan. Do NOT load for plans without stack interaction (pure-function-only-tasks), for plans where stack-mode is explicitly documented, or for the initial plan-writing phase (writing-plans has its own self-review).

0
installs
▌
Enum Value Discovery Before SQL Where · ed3design
Use BEFORE writing any SQL WHERE-clause that filters on a string/enum-typed column. Schema-verify via `\d <table>` shows COLUMN TYPE (text/varchar/enum) but NOT the actual values used. Code may set 'taken' while the reviewer thinks 'accept'. Pattern: run `SELECT DISTINCT <col> FROM <table>` (or grep for `_update_<col>`-style setters) to discover the actual value-set BEFORE formulating WHERE. Without this discovery step, queries silently return wrong counts: rows matching the real value get excluded, user sees "0 results" while reality has many. Trigger on phrases like "how many entities with status X exist", "user_response='accept'", "SELECT ... WHERE enum_col=...", "why am I seeing no hits", "forensic DB analysis", "cockpit filter shows 0". Do NOT load for known well-defined PostgreSQL ENUM types where `\d` shows values inline, first-time-CREATE-TABLE queries, or non-text/non-enum columns.

0
installs
▌
Plan Execution State Drift Precheck · ed3design
Use before executing any superpowers/gsd-style implementation plan (`docs/superpowers/plans/*.md`, `.planning/PLAN.md`, `roadmap-phase-*.md`) whose plan-file was written in a previous session — to detect whether tasks have already been implemented (in a parallel session, by a different agent, or by the user) before re-executing them. Trigger on phrases like "start plan execution", "apply executing-plans skill", "gsd-execute-phase", "execute phase", "plan file is from yesterday/last week", "plan written earlier, now executing". Without `git log <base>..HEAD` precheck, completed tasks can be re-implemented inline, wasting significant time. Do NOT load for plans written in the SAME session (no drift possible), plans without git-tracked code targets (pure-documentation phases), or when the user explicitly states "the codebase is at the pre-plan state".

0
installs
▌
DB Telemetry Primary Docker Logs Secondary · ed3design
Use when investigating missing or unexplained behavior in a containerized stack where a high-volume job (MQTT ingester, 5m-fetcher, scraper) runs in the same container as diagnostic jobs, and Docker logs show nothing for the time period in question. Symptom: `docker logs --since 72h` returns only recent lines; older diagnostic entries are gone despite the container running continuously. Root cause: Docker's default JSON log driver rotates files at ~10MB — high-volume sibling output pushes out older diagnostic lines within hours. Fix: query DB-side telemetry (tick_log, job_log, metrics tables) as primary source; Docker logs are only reliable for the last 30–60 minutes. Trigger on phrases like "docker logs shows nothing", "no logs from yesterday", "log rotation", "scheduler history gone", "where are Friday's logs". Do NOT load for fresh containers without DB telemetry infrastructure, single-process containers where log rotation isn't an issue, or log-streaming setups (Loki, CloudWatch, Datadog).

0
installs
▌
Roadmap Phase Execution Verify First · ed3design
Captures a pattern from a Phase-A execution session: when executing a roadmap phase from a knowledge vault that was designed days/weeks ago AND a previous session may have prepared draft artifacts (service maps, status files, execution guides), verify each item against current reality (DB queries, docker inspect, systemctl, filesystem) BEFORE applying changes. Find drift in pre-existing files; document discoveries that turn a routine item into an issue; never check a roadmap item as done just because the roadmap said so. Trigger on phrases like "implement Phase X", "execute roadmap item", "implement Phase A of … consolidation", "item Y from the roadmap", "execute the phase from the vault". Do NOT load for fresh roadmap design (use brain-dump-to-phased-roadmap), for executing a freshly-written task list with no vault history, or for non-vault roadmaps.

0
installs
▌
Subagent Self Reflection Prompt Pattern · ed3design
Use when dispatching a subagent to test a skill, evaluate a tool, or perform any non-trivial task where YOU (the caller) want meta-feedback about the experience — what worked, what was unclear, what was missing. Include a mandatory "## Skill-Self-Reflection" section in the prompt asking 3-4 introspective questions. Without this, you only get task output, not improvement signal. Trigger on phrases like "dispatch subagent for skill test", "skill TDD pressure-test", "evaluate this tool via subagent", "subagent meta-feedback", "how do use subagents for skill improvement". Do NOT load for production-task dispatch (only output matters, not reflection), for performance-critical dispatches (reflection adds tokens), or when the caller already has a strong skill-content hypothesis to test against (then use direct A/B comparison instead).

0
installs
▌
Library Subclass Explicit Type Classification · ed3design
Use when classifying exceptions or other library-provided objects by type AND the semantically-distinct behaviors map onto a class-hierarchy where subclasses inherit from a base with DIFFERENT desired handling. Common in retry-logic for HTTP clients (requests/httpx — Timeout vs HTTPError vs ConnectionError), Telegram bots (BadRequest inherits from NetworkError but should NOT be treated as network), SQL clients (OperationalError vs ProgrammingError), file IO (FileNotFoundError vs PermissionError vs OSError). Trigger on phrases like "retry logic for TelegramError", "isinstance vs type()", "exception type check", "subclass trap", "HTTPError vs Timeout". Produces class-hierarchy mapping via `mro()`, explicit type-classification helper, and tests locking the distinction. Do NOT load when all hierarchy exceptions should be handled identically, when docs explicitly state "always catch base class", or for first-time exception-handling design.

0
installs
▌
Strategic Questions Before Code Touch · ed3design
Use when about to start a multi-architecture-decision feature implementation (Phase-X-Vision-Spec, complex refactor, new module that touches 3+ existing modules) AFTER Reality-Inventory but BEFORE first code-touch. Pose 2-4 strategic questions via AskUserQuestion that lock in: (a) scope (atomic-block vs phased), (b) model/algorithm choice when ≥2 valid options exist, (c) persistence-decision (new column vs JSONB vs new table), (d) backward-compat strategy. Each question with 2-4 specific options + Recommended-marker. Trigger on phrases like "start Phase X", "implement Vision-Spec", "build new module for X", "refactor Y", "larger code change", "multiple architecture decisions open". Do NOT load for single-bug-fixes, for tasks with only one reasonable approach, when scope/persistence/model are obvious from existing code, or when user explicitly says "just start".

0
installs
▌
Forensic Hypothesis Disproved Then Read Code · ed3design
Use when conducting a forensic investigation with explicit hypotheses (H1/H2/H3) on a system bug or anomaly, and 2+ hypotheses have been disproved by code-read or DB-query. Default-behavior is "Hypothesis disproved → investigation done, no real bug". This skill says: continue code-read with no specific hypothesis — bonus-findings often surface during the disproving process and are real bugs that would be missed otherwise. Trigger on phrases like "hypothesis H1 disproved", "all theories wrong", "forensics inconclusive", "no bug found but weird behavior", "abort forensics", "nothing there after all". Do NOT load for hypothesis-testing in research code where "disproved" is success, for time-boxed forensics with a hard stop after X minutes, when user explicitly says "if the hypotheses are disproved Claude are done", or for non-investigative tasks.

0
installs
▌
Explicit Unknown Counter Vs Coalesce Mask · ed3design
Use when writing aggregating SQL (SUM/AVG/COUNT) or Python-side aggregates over a NULL-able column where NULL means "data not present / not backfilled / unknown" (NOT "intentionally zero"). The naive `COALESCE(SUM(x), 0)` or `df.col.fillna(0).sum()` masks NULL-rows silently — drift goes undetected for weeks. Instead, ALWAYS pair the aggregate with an explicit `count(*) FILTER (WHERE col IS NULL)` Counter (Postgres) or `df.col.isna().sum()` (pandas), surfaced in the same response shape. Trigger phrases like "aggregate PnL", "monthly sum", "trade statistics", "NULL handling", "summary report with NULLable column", "why doesn't the aggregate match the memory", "drift in reporting". Do NOT load for columns where NULL is semantically zero (intentional NOT-NULL-DEFAULT-0 design — then COALESCE is correct), for non-aggregating queries (single-row SELECTs), or for transient runtime calculations where NULL means "in-flight" rather than "unknown".

0
installs
▌
Strategic Proposal Vault Persistence Check · ed3design
Use at session-end (or mid-session when about to wrap a strategic discussion) when the session has produced structured strategic content — multi-row tables (priority/effort/value matrices, tool inventories), JSON/data schemas (API responses, config-shapes), multi-step recommendations ("Stage 1:..., Stage 2:..."), 5-category frameworks, or anything that took >10min to structure. Risk: this content lives in the conversation buffer, NOT in persistent knowledge — when context expires the entire structuring effort is lost. Trigger phrases like "session wrap-up", "end of day", "is that in the vault?", "did Claude capture that?", "summarize for later", "remember", "wrap up". Do NOT load for sessions producing only ephemeral content (chat-only, single-file-edit, debug-trace), mid-task while strategic discussion is still active, or when post-session-skill-review is already covering the same scan.

0
installs
▌
DOCX Tab Position Extraction For Layout Replication · ed3design
Use when replicating a document layout (business letter, invoice, contract) from an existing Word `.docx` file in HTML/CSS/PDF/Print-CSS — a user provides a previous Word document as "make my web letter look like THIS" and you need precise tab-stop / margin / indentation positions. STOP and extract the actual measurements from the DOCX XML before writing CSS by eye. DOCX is a ZIP-archive containing `word/document.xml`; tab stops live in `<w:tab w:pos="6803" />` where `w:pos` is in **twips** (1/1440 inch); convert with `mm = twips ÷ 1440 × 25.4`. The same applies to margins (`<w:pgMar>`), indentation (`<w:ind>`), and column widths (`<w:gridCol>`). Trigger on phrases like "replicate the layout from my old Word letter", "make the layout like the DOCX", "convert twips to mm", "measure the layout, don't estimate it". Do NOT load for designing a layout from scratch, for `.doc` binary legacy format (convert via LibreOffice headless first), for `.docx` where layout is irrelevant, or when the reference is a PDF.

0
installs
▌
Reporting Artefact Detection Before Claiming Anomaly · ed3design
Use when observing a "surprising anomaly" in backtest output, SQL query result, multi-run-eval-report, ML-model-performance-table, or any reporting-layer artefact suggesting a system bug, market outlier, methodological problem, or drift. Before treating the anomaly as real and dispatching forensic resources, run a 3-step triage: (1) NULL-handling check — are NULLs in numerator/denominator mishandled, was IS NOT NULL omitted? (2) Cross-window / unique-ID check — do overlapping sub-windows / joins count rows multiple times? (3) Methodology-consistency check vs previous report — was the same SQL replicated exactly? Trigger phrases like "why is WR suddenly so low", "I don't understand this anomaly", "24h drift", "baseline has changed", "backtest gives different numbers today than yesterday". Do NOT load for confirmed-real anomalies, first-time-setup-debugging without baseline, code-bugs in the algorithm itself, or UI rendering bugs.

0
installs
▌
Subagent Mode Selection Continuous Vs Review Between · ed3design
Use when starting a multi-task workflow via `superpowers:subagent-driven-development` (SDD) and the user must choose between two execution modes: (A) Continuous Execution — all tasks dispatched back-to-back without checkpoint (SDD default), or (B) Review-Between-Tasks — user inspects each task's output before authorizing the next. Mechanical-implementation tasks (TDD with complete code in plan, deterministic outcomes) are continuous-safe. Judgment-heavy tasks (forensics, interpretation of numbers, strategic decisions, architectural pivots based on subagent output) require review-between because the next task's prompt depends on prior outcome interpretation. Trigger phrases like "should I run continuous or with pauses between tasks", "review between steps", "subagent-driven with checkpoints", "pause after each task". Do NOT load for single-task workflows, non-SDD workflows, purely mechanical TDD with complete code in plan, or the very first task of a workflow.

0
installs

64 published skills