diolog-plugins

End-to-end product-positioning pipeline. From a company context it generates two Google Gemini Deep Research prompts (a positioning brief + a product-research-persona market brief), renders a copy-and-launch HTML with animated Gemini instructions (select Deep research from the + menu; Share & Export → Copy contents), then — once the research comes back — synthesises three framework-grounded positioning territories (Ries & Trout, April Dunford, Blue Ocean, David C. Baker) as Markdown plus a stylised interactive decision page.

Analyze product discovery and customer feedback documents using the Discovery Sentinel persona. Produces Feedback Classification Reports, Discovery Insight Briefs, and Prioritised Opportunity Assessments.

Generate validated, prioritized product feature concepts and outcome-based roadmaps for AI-assisted IR/compliance/governance SaaS. Supports feature ideation, roadmap construction, feature evaluation, data ingestion, and comparative prioritization.

Turns a vague research need into a single copy-paste-ready Google Gemini 3.1 Pro Deep Research prompt — with pseudo-XML scaffolding, archetype-specific overrides (technical / competitive / regulatory / academic / forecasting), epistemic bounding tags, inline citation protocol, and wrap-around Operator Notes (Plan Review, decomposition, adversarial audit).

High-signal code review for NestJS APIs and Next.js (App Router) + React 19 apps. Modular router skill that delegates to framework-specific checklists (NestJS, Next.js, TypeScript, OWASP security), enforces a >85% confidence threshold, and runs a Chain-of-Verification pass to suppress hallucinated findings. Reports in a fixed CRITICAL/HIGH/MEDIUM/LOW taxonomy with file:line, exact quote, and fix snippet. Read-only — reports findings, does not modify code.

Reverse-engineer a product's visual design system from one or more website/app screenshots and produce a single authoritative DESIGN.md — a framework-agnostic, token-based spec (palette, typography, spacing, shape, motion, component inventory, voice, do/don't) with per-token provenance marks, so another AI (Stitch, Claude, v0, Cursor, AI Elements) can generate new screens that unmistakably belong to the same product.

Compress a verbose source document — README, API docs, research paper, technical guide, library docs — into a maximally dense, semantically complete Markdown reference (written to a `<source>.summary.md` file) that another LLM or a skimming human can consume in a fraction of the tokens. Uses a triage-tag system ([CRITICAL]/[WORKFLOW]/[POWER-USER]/[GOLDEN-NUGGET]/[DEPRECATED]), contextually integrated tips, solution-first problem framing, multi-tier feature capture, and a mandatory Strategic Synthesis footer (Maturity Model + Feature Selection Matrix + Workflow Progression Ladder). Target compression 60–80% while retaining 100% of semantically unique information. Tuned for Claude Opus 4.7.

Reverse-engineer a slide deck's visual design system from one or more slide screenshots and produce a single authoritative PRESENTATION_DESIGN.md — a tool-agnostic, token-based spec (canvas, palette, typography, slide archetypes, chart style, image treatment, iconography, motion, do/don't) hard-capped at 1,700 characters so another AI (Gamma, Beautiful.ai, Pitch, Keynote/PowerPoint co-pilots, Stitch, v0, Claude, Cursor) can generate new slides that unmistakably belong to the same deck. Sibling to design-md-from-screenshots but tuned for slides: fixed 16:9 canvas, slide archetypes, chart data-ink discipline, image treatment conventions, and on-slide positional grammar.

Generates dense, agent-ready persona definitions from a target role — identity kernel, responsibility matrix with classification tags ([CRITICAL] / [WORKFLOW] / [POWER-USER] / [GOLDEN-NUGGET]), decision frameworks, maturity model, selection matrix, capability heat map, dependency graph, metrics, constraints, and two interaction examples. Tuned for Claude Opus 4.7 (literalism, adaptive thinking, positive framing). Evidence base from 2025 persona research (EmoCharacter, LABE, PPA, CPER, Over-Specification Paradox) ships in references/playbook.md.

Create Linear issues in the Diolog workspace from a code-review markdown report. Each `### [SEVERITY] Title` finding becomes one issue with severity (Critical/High/Medium/Low) and type (Vulnerability/Bug) labels and Todo status. Preserves the reviewer's exact prose, file:line citations, fix recommendations, and confidence scores. Triggers on phrases like 'log these to Linear', 'create Linear issues for each finding', 'import this code review into Linear', or any prompt that points at a markdown file with `[CRITICAL]`/`[HIGH]`/`[MEDIUM]`/`[LOW]` severity-tagged sections.

Three native skills that run the Diolog Linear issue pipeline — triage, plan, and worker — entirely inside your interactive Claude Code session (no Agent SDK, so usage draws from your standard interactive allowance, not the separate Agent SDK credit). linear-triage runs a technical + Specification Sentinel product review and posts a non-technical readiness comment; linear-plan classifies a tier, investigates the codebase, writes docs/plans/{id}.md and comments the repo-relative path (no file upload); linear-worker implements a planned issue in an isolated worktree via dynamic ultracode workflows (understand → implement → rebase → acceptance review → resolve), with no remote PR. The plan and worker fan out parallel subagents via the Workflow tool (in small batches to avoid throttling) to speed up large investigations. The worker verifies each phase against the plan + ticket before advancing (not just at the end) and runs all phases through to completion.

Four native skills that run a Linear-free, markdown-doc feature pipeline — /triage, /plan, /work, /gap-fix — entirely inside your interactive Claude Code session. /triage turns a feature idea (inline text or a notes file) into a versioned spec at docs/specs/spec-DIO-0001.md (id allocated from docs/feature-specs/LEDGER.md), running a codebase grounding pass plus a Specification Sentinel product/UX/compliance review and appending a non-technical readiness section. /plan classifies a tier, investigates the codebase, writes docs/plans/plan-DIO-0001.md and links it from the spec. /work implements the plan in an isolated worktree via dynamic ultracode workflows (understand, implement, rebase, acceptance review, resolve), appends a progress section to the spec, and leaves the branch local — no remote PR. /gap-fix runs after /work as the remediation step: it re-enters the work branch, always re-audits the delivered code against the original spec (merging in any human/QA gaps you provide), and implements the fixes in code (file-disjoint fan-out + typecheck gates), looping audit-fix until only optional Low items remain, then commits locally and appends a gap-fix progress note — no remote PR. A doc-driven sibling of linear-issue-pipeline that needs no Linear MCP.

Keep the Diolog marketing/feature documentation set in docs/marketing/ current when a feature ships or a Linear ticket lands. Updates the four-file set per area (features-build/final/XX-*.md + existing-features.md section 2.XX for technical detail; features-build/plain/XX-*.md + product-feature-guide.md section XX for plain language), plus outbound-contact-surfaces.md for new contact/sharing/delivery surfaces. Enforces the content standards (technical files carry component names, routes, GraphQL ops and exact copy with no opinions; plain files carry zero technical terms, second person, sentence case, no em dashes, no emojis), four-file consistency, the supersede-don't-accumulate currency rule, and the live-app > source > ticket source-of-truth hierarchy. Operationalises docs/marketing/MAINTENANCE.md.

Validate whether a specification, build plan, or Definition of Done is GENUINELY implemented in a large codebase — not just rendered, schema-valid, and passing tests. Classifies every claimed-done data field as REAL (a producer computes it from the filesystem / git / discovery / AI / a live API), AUTHORED (read from persisted state but only ever written by a UI round-trip or a seed — nothing computes it), or MOCK (only ever a fallback constant), each with file:line evidence. Fans the work out across parallel investigators, adversarially verifies the highest-impact findings before reporting, and writes a ranked, date-stamped living gap report that doubles as the resolution backlog. Built to catch demo-data-dressed-as-done and to re-validate after a prior '100% complete' claim — the core insight being that renders + schema-valid + tests-pass never proves a real producer exists.

Turn Claude into an opinionated, accessibility-aware, AI-slop-resistant design collaborator that produces intentional design artifacts in plain HTML/CSS/SVG/JS — landing pages, app screens, dashboards, interactive prototypes, slide decks, wireframes, hi-fi variations, design-token files, and component inventories. A router skill carries the full design philosophy (content discipline, purposeful aesthetics that reject AI-template tropes, visual hierarchy and rhythm, typography and color systems, WCAG accessibility, interaction states, system thinking) and routes to 14 phased procedures: discovery-questions, frontend-aesthetic-direction, wireframe, make-a-deck, make-a-prototype, make-tweakable, generate-variations, design-system-extract, component-extract, accessibility-audit, ai-slop-check, hierarchy-rhythm-review, interaction-states-pass, and polish-pass. Built for Claude Code: AskUserQuestion kickoff rounds, Agent-tool verifier fan-out, and self-contained deck-scaling / device-frame / tweak-panel code that runs as standalone files with no external dependencies.

Turn a named Diolog feature (or several) into email-ready product-mockup graphics on a Figma canvas, for product-update / marketing emails. Reads the feature's real context — docs/marketing/product-feature-guide.md + features-build/plain/NN-*.md + the rendered mock UI read in a browser via playwright-cli (the served web / customer / investor design-system hosts) — then designs and builds, via the design-craft skill, impression-not-replica mockups that lead with the feature's payoff (a full product-window app shot — the complete app shell in a clean window — for hero features, plus a product-surface vignette, soft panel + peeking device, collage/overlap, phone bezel, and a website frame for actual public sites) and make the product look genuinely smart (a real insight, an italic quote from the record, named source chips) as titled, spaced artboards in one self-contained HTML file using the live Diolog design tokens, verifies the render in a browser, and recreates the layout in Figma via whatever write-capable Figma MCP is connected (deleting the HTML only after a successful build). Each artboard also carries a brief non-technical marketing caption beneath it for IR teams and the agencies who serve them (no em-dashes), with an optional email-hero split format, and semantic emphasis via a soft wash and icon rather than AI-slop left-only borders; large sets fan out parallel builders against one master brief and pass a deterministic verification lint. If no Figma MCP is available, the HTML file is retained as the final deliverable.

Three macOS-native UI skills sharing one bundled knowledge corpus (the full macOS 26 'Tahoe'/Liquid Glass HIG library + a token-level DESIGN.md + the macOS 26 UI Extraction & Native Translation framework). `macosify` refits an existing UI to feel authentically AppKit-native on macOS 26, correcting iOS-derived looks (Mac Catalyst / 'Designed for iPad' on Apple Silicon) toward true native. `macos-ui-analyst` (the GlassReader persona) analyses a static macOS 26 screenshot into a structured Native Translation Report (AX-tree inventory + SwiftUI/AppKit mapping) and merges durable learnings into one accumulating knowledge file. `macos-storyboard` reads the entire corpus, then builds an interactive StyleX + Storybook storyboard of a specification's user flows — a reusable design system (tokens → elements → composites) with every screen rendered across happy / empty / loading / error / AI states, using the design-craft and frontend-design skills for bespoke, accessible direction.

Build an interactive UI storyboard as a StyleX + Storybook project from a product specification and a user-supplied DESIGN.md. The DESIGN.md (the product's own brand/design system) drives the look — NOT locked to a macOS aesthetic, so the storyboard renders in whatever visual identity the brand specifies. It reads a bundled HIG library purely as the interaction, behaviour, structure, and accessibility backbone (layout, master–detail/list/table grammar, modality, feedback, focus/keyboard, motion, empty/loading/error/status, writing), uses the design-craft and frontend-design skills for distinctive, accessible, AI-slop-resistant direction, derives the user flows + screens, builds a reusable StyleX design system (tokens → elements → composites) from the DESIGN.md, and implements every screen as Storybook stories across the happy / empty / loading / error / AI states at production fidelity, plus an MDX flow-overview that sequences the screens into journeys. A brand-driven sibling of macosify's macos-storyboard skill (which is locked to a macOS-native look).

Validate that an implemented React or React Native UI faithfully reproduces a reference mockup (HTML+CSS, served prototype, Figma export, or another rendered component set), then update the code to close every gap — by measuring, never eyeballing. Treats the mock as the source of truth and asks (full-comparison and per-screen) before removing working functionality; builds a complete screen/frame inventory and never silently drops a frame; renders both sides; inverts the burden of proof (a visible difference is a defect until a citation proves it intentional); diffs structure first then per-property computed styles; produces a per-screen present/divergent/absent ledger AND a functional-gaps document for newly-added UI that is only visual. For React Native it measures the RENDERED tree — structural/accessibility extraction (axe describe-ui / Maestro hierarchy) plus resolved style props over the Metro CDP connection (rozenite / agent-cdp) — and forces every screen's measurement to disk as artifacts, so a 'match' verdict can never come from a screenshot, a source read, or reasoning (frontier vision models catch under half of fine-grained UI differences); navigation is deep-link-first (xcrun simctl openurl) because a Maestro tap carries a ~15-20s XCUITest startup tax. For a React web target the comparison is symmetric DOM-to-DOM — reference and target are both read via getComputedStyle through one extractor at the same viewport, with the app chrome (sidebar/header/nav) in scope. Generic and framework-agnostic. Merges and replaces ui-fidelity-audit + mockup-align. Adds a mechanical STRUCTURE/LAYOUT differ (structure-diff.mjs — grid/flex/missing-node/order, the class a per-property style diff is blind to), a CONTENT/data differ (content-diff.mjs), a zero-dep visual pixel-overlay (overlay.mjs), a decorative-subtree HTML-to-React converter (capture-subtree.js + to-stylex.mjs — embed pixel-exact or StyleX skeleton with token mapping), a per-section parallel fan-out workflow, and a Storybook visual-regression pattern.

Write any content in Luke Rhodes' authentic voice (Diolog CTO and co-founder), conditionally routed through the right persona variant for the content type: LinkedIn posts and long-form blog articles (engagement-optimised, with a Diolog graphic concept), marketing content (announcements, release notes, landing copy, campaign emails), code reviews (severity-calibrated candour: softened preferences, plain blockers, always a concrete path), informal-but-professional Slack messages (context, ask, a genuine out), short-form content (tweets, LinkedIn comments, bios), and ADHD-targetted / book-audience writing (the conversational brilliant-colleague register: hooks, short segments, concrete-first, strategic repetition, one try-today action). One non-negotiable base voice (calm, direct, technically fluent, quietly witty, no em dashes, no AI cliches) synthesised from Luke's raw writing corpus (LinkedIn posts, work messages, a shipped product announcement, an SOW, a technical explainer, discovery notes), five persona deltas layered on top, and a deterministic voice-lint that hard-fails on em dashes and AI-tell phrases in every format with per-format advisory checks. Formerly create-luke-article (v1 was LinkedIn/blog only).

Turn any web feature's requirements into an acceptance-criteria-traceable Playwright e2e UI suite. From a requirements source (an issue/ticket, a spec or plan*.md, or a description) + the running app, it enumerates every acceptance criterion into a traceability matrix, grounds selectors against the live page, authors specs in the PROJECT'S OWN harness that assert content/render correctness (a chart actually draws, a figure is actually sourced) rather than mere element presence, runs them with isolation-safe disposable data, and fixes the tractable product bugs the suite surfaces. Project-agnostic: it discovers the repo's harness, auth, tenant/context model, run command, and base URL rather than assuming any one stack. Ships a portable e2e-playbook plus an optional Diolog-specific worked example.

Three skills that write publish-ready, on-brand content in Diolog's brand voice (Australian investor-communication SaaS; 'the workspace for everything investor-facing'; tagline 'Disclosure, without doubt.'), all driven by one bundled brand-voice persona and gated by one deterministic voice-lint. create-diolog-article writes long-form articles / blog posts / thought-leadership across the investor-education, IR-best-practice, thought-leadership and announcement registers. create-diolog-marketing-copy writes website marketing copy and marketing emails (benefit-first heroes, feature-to-'so what' bullets, problem-callback CTAs). create-diolog-business-case writes buyer-facing ROI / justification documents for the CFO / Company Secretary / board (status-quo cost, what changes, proof/security/compliance posture, measurable outcomes, next step). Every skill hard-encodes the house rules: no em or en dashes (spaced hyphen only), Australian English, sentence-case headings (except product feature names), every statistic carries an inline (Source, Year) with zero fabrication, compliance confidence capped at 95%, no financial advice or guaranteed outcomes, the Diolog narrative arc, correct register selection, and critique the old way of IR never the reader. The fuller brand counterpart to the deployed diolog-content-writer / diolog-linkedin-writer prompts; personal-voice LinkedIn posts remain with create-luke-content.

End-to-end feature delivery conductor for your product. Takes ONE feature (inline description or a markdown file) and drives it from a bare idea to merged, tested, production code by orchestrating the existing skills in a single in-session flow: design-craft (represent the whole feature UI in the design-system elements/composites/mock-pages, grounded in the repo's design system — e.g. apps/web-design-system — plus an optional DESIGN.md design-language spec when provided or present, and any provided HTML/CSS/JS mock) → triage (spec) → plan → work (isolated worktree) → a deferred-work loop (re-work, or child triage+plan+work for extra phases, all on the SAME branch) → gap-fix → acceptance-e2e (a comprehensive Playwright suite over every user flow/action/menu, run against the feature branch locally and fixed) → finalize (commit → rebase → merge into the integration branch → push → clean up worktree(s)). Stays in-session to keep the accumulated feature context across every stage and leans on the on-disk spec/plan/mock artifacts as durable, resumable memory; one feature = one branch = one worktree, with the merge behind a fail-closed pre-merge gate. Builds on the design-craft, feature-spec-pipeline, and acceptance-e2e plugins.

Backlog-wide feature-delivery orchestrator. Surveys ALL remaining feature work in a product repo — LEDGER.md, docs/specs/spec-*.md, docs/plans/plan-*.md, untriaged briefs in docs/features-to-triage/, refined HTML mocks in design/mocks/html, deep research in docs/deep-research/ — reconciles any in-progress worktrees, then writes ORCHESTRATOR.md (a combined plan + ledger for everything left) and orchestrator-hierarchy.html (a visual dependency hierarchy) BEFORE any execution. It then drives the backlog to done by running the ship-feature skill per feature: dependency-ordered, up to 8 concurrent Opus runner agents, with mechanical plan-scoped coding optionally delegated to the Cursor CLI (composer-2.5) and verified/fixed by Opus, while the orchestrating session itself stays on the session model. Includes a preflight that checks the project's directory/file conventions (offering to clone diolog-team-files for CODING_PRACTICES.md / NEW_PROJECT_BEST_PRACTICES.md, gather stray feature briefs into docs/features-to-triage/, and validate the monolith layout against NEW_PROJECT_BEST_PRACTICES.md). Builds on the ship-feature plugin (and through it design-craft, feature-spec-pipeline, acceptance-e2e).

Build a branded, print-ready customer proposal / pitch deck from Diolog's 9-slide template system. Fills company-agnostic templates with a specific client's identity, contacts, pricing and numbers (prompting with multiple-choice questions for missing details), keeps the IR-proposal spine, and can design new slides into the same system via design-craft. Outputs a single self-contained web page with pan/zoom (trackpad + controls, fit-deck / fit-slide / 100%) that prints to a vertical, paged PDF at native 1920×1080 slide size.

Generate a spec-compliant DESIGN.md for any live website from its real pages — the browser-driven, measure-first successor to design-md-from-screenshots. Given a URL it uses playwright-cli (isolated named sessions, parallel probe agents with rate-limit backoff, full-page screenshots + getComputedStyle-by-role measured tokens + a colour census) to MEASURE the design of the key pages (home, about, product/services, contact, and any investor hub/portal) instead of guessing hexes and fonts from a screenshot, then synthesises an authoritative DESIGN.md in the official google-labs design.md format (YAML token frontmatter + Overview/Colors/Typography/Layout/Elevation/Shapes/Components/Do's & Don'ts + per-token provenance + self-critique) and refines it into an intentional, upgraded identity.

Generate a single printable A4-page executive business case in Diolog's house style from a customer's proposal deck. Uses the /design-craft skill against a bundled single-page DESIGN.md and a templated version of the Alfabs business case, with all copy in the Diolog brand voice (create-diolog-business-case). Produces one dense, print-clean page (problem, solution, value, quantified outcome, investment, next step) on a fixed 794x1123 A4 canvas that prints to exactly one page.