45ck

Plan, build, and fix short-form videos like an editor, using hook-first structure, caption-aware visual design, Remotion/FFmpeg assembly, and reject-regenerate review loops instead of one-shot automation.

Build a full short from brief to reviewed MP4 while keeping script, audio, visuals, captions, and validation aligned as one edit.

Generate and evaluate multiple short-form hook, title, cover, opening-frame, and platform-packaging variants before scripting or rendering, then choose a default and preserve the rationale.

Turn publish receipts and performance metrics into reusable style-profile or niche-profile updates that say what to repeat, kill, or test next.

Generate platform-specific publish metadata, fit checks, and upload checklists for short-form and social video without auto-uploading.

Review scripts, timelines, scene plans, or rendered shorts for retention and mobile pacing before final render approval or publish readiness.

Review a short before or after production using quality gates for hook, retention, clarity, payoff, risk, and platform fit without promising guaranteed virality.

Extract approved longform highlight candidates into clip-local video, audio, timestamps, visuals, and clip-plan artifacts after selection, boundary snap, and approval.

Handle /loop-style requests for finding, adapting, drafting, and preparing bounded agent loops without treating external loop catalogs as authorization.

Turn external skill, rule, plugin, MCP, task-memory, and multi-agent workspace patterns into safe fixture coverage rather than live dependencies.

Check whether host instruction surfaces such as AGENTS.md, CLAUDE.md, Codex agents, Cursor rules, Copilot instructions, and SKILL.md files have drifted apart.

Review skills generated from recorded workflows before they are installed, shared, or treated as reusable automation.

Review skills, agents, rules, plugins, and MCP/tool packs for license, source, script, permission, and supply-chain risk before adoption.

Choose the right task-memory and issue-state pattern for a repo: Beads, lightweight files, external tracker integration, or no durable task memory yet.

Review third-party skill, agent, rule, and plugin repos for format fit, provenance, and first-party adoption paths without treating them as direct harness dependencies.

Synthetic skill for intake scanner coverage.

Run a cognitive walkthrough and create Beads issues from the findings. Converts walkthrough breakdowns (Q1-Q4 failures) into trackable Beads tasks with priorities and dependencies.

Build a conceptual model and create Beads issues from the findings. Converts ambiguities, overloaded concepts, and unclear states into trackable Beads tasks with priorities and dependencies.

Audit cross-screen consistency and create Beads issues from the findings. Converts consistency breaks and invariant violations into trackable Beads tasks with priorities and dependencies.

Audit failure paths and create Beads issues from the findings. Converts unhandled failure states, missing empty states, and broken recovery paths into trackable Beads tasks with priorities and dependencies.

Run a heuristic evaluation and create Beads issues from the findings. Converts Nielsen heuristic violations into trackable Beads tasks with priorities and dependencies.

Review information architecture and create Beads issues from the findings. Converts orphan screens, mislabeled navigation, and grouping problems into trackable Beads tasks with priorities and dependencies.

Map user journeys and create Beads issues from the findings. Converts dead ends, missing recovery paths, and confusion points into trackable Beads tasks with priorities and dependencies.

Run a full HCI review pack and create Beads issues from the findings. Converts scorecard weaknesses and confusion risks into trackable Beads tasks with priorities and dependencies.

Assemble a grounded review prompt from a local artifact bundle so Codex or Claude Code can inspect the right files and ask the right questions.

Check a local video against layout annotations, safe zones, OCR text boxes, and frame samples so agents can catch cropped content, caption overlap, unreadable overlays, and platform-unsafe composition before shipping.

Collect first-pass source media facts, audio silence/energy, shot estimates, representative frame status, and persistent text/caption risk evidence.

Review a rendered video for technical defects such as resolution mismatch, missing or near-silent audio, black or white frames, edge gutters, low motion, sparse caption bands, and layout issue pass-through.

Fuse video shot segments with storyboard frames, OCR, transitions, and timeline artifacts into one per-segment evidence map for grounded video review.

Extract at least one storyboard frame per video shot segment so later OCR and segment evidence fusion can cover gaps missed by global sampling.

Normalize a local video run into a consistent artifact bundle by resolving output roots, latest pointers, known reports, and the primary video path.

Extract coarse shot and scene-change segments from a local video, with optional representative frames for each part.

Generate a polished product demo video from a YAML spec using demo-machine. Use when the user wants to create, run, or update a demo video for their app.

Generate a complete demo-machine YAML spec by crawling a live web app. Give it a URL and description, get a ready-to-run spec.

Automatically fix a broken demo-machine spec by analyzing failure artifacts (screenshots, DOM, error logs). Use when a demo fails after a UI change.

Generate compelling AI narration for every step in a demo-machine spec. Use when a spec has no narration or needs better narration text.

AI quality review of a completed demo run. Analyzes event log, timing, and narration to flag issues and suggest improvements.

Convert an existing Playwright or Cypress E2E test file into a demo-machine YAML spec. Reuses test coverage as demo scripts.

Translate all narration text in a demo-machine spec to another language, producing a localized copy.

Debug a failing demo-machine spec. Use when a demo capture or pipeline run fails with errors.

Turn interview notes, assumptions, or market context into customer discovery findings, jobs-to-be-done synthesis, and actionable product/GTM recommendations.

Create or audit an event tracking plan for product, growth, and analytics workflows. Use when a team needs a source-of-truth taxonomy, instrumentation plan, and data governance rules.

Turn a product or growth idea into a rigorous experiment brief and post-test readout format.

Build a coordinated product/marketing launch plan with messaging, assets, milestones, instrumentation, and post-launch review.

Define or critique a product North Star Metric and its input metrics. Use when a team needs one shared leading indicator of customer value and growth.

Audit a signup, onboarding, and activation flow to identify friction, missing value discovery, and concrete product/growth fixes.

Build or refine B2B/SaaS positioning, message hierarchy, and proof points from customer pains, differentiation, and market context.

Create a pricing and packaging hypothesis, research plan, and low-risk validation path tied to customer value and unit economics.

Route clearly-specified single-function implementation tasks to a local Ollama model (qwen3-coder:30b or equivalent) to save frontier API output tokens. Falls back to frontier on oracle fail. Use ONLY for single-function tasks with a deterministic test; do NOT use for multi-file refactors, debugging existing code, or app-build orchestration.

This skill should be used when the user asks to 'run QA', 'quality audit', 'test the website', 'run E2E tests', 'lighthouse audit', 'check accessibility', 'visual regression test', 'run Playwright tests', 'quality gate check', or wants comprehensive quality verification of a web project. Use case-by-case when generated sites need validation beyond basic checks.

This skill should be used when the user asks to 'check if ready to deploy', 'pre-deploy check', 'verify before deploying', 'deployment readiness', 'is it ready to ship', or wants pre-deployment verification.

This skill should be used when the user asks to 'validate a flow', 'check my flow', 'lint this flow', 'is this flow correct', 'flow errors', 'flow warnings', or wants to analyze a prompt-language flow for issues before executing it.

This skill should be used when the user asks to 'fix the tests', 'make tests pass', 'tests are failing', 'fix and test', 'green the tests', or wants to iteratively fix failing tests until they pass.

This skill should be used when the user asks to 'refactor this', 'clean up this code', 'make this cleaner', 'safe refactor', 'restructure this', or wants to refactor code with continuous test verification.

This skill should be used when the user asks to 'do TDD', 'test-driven development', 'red green refactor', 'write a failing test first', or wants to implement a feature using test-driven development.

This skill should be used when the user asks to 'write a flow', 'create a flow', 'design a flow', 'make a flow for', 'I need a flow', or wants to create a prompt-language flow for a task. Decides whether a flow is needed at all — most tasks don't need one.

Initialize a new SDLC monorepo with Storybook planning hub, pnpm workspace, and git configuration. Use when starting a new project.

Iterative planning wizard with client validation at each stage. Generates SDLC artifacts in proper dependency order (scenarios → workflows → models → data → API → design).

Sync and search local reference repositories (curated awesome-* lists) to support planning/design decisions.

Implement software from validated planning artifacts using TDD and quality gates. Reads /sdlc:plan outputs and guides proper implementation.

Quality assurance verification. Checks test coverage against thresholds, validates test quality, identifies E2E/integration gaps, runs security dependency audit, performs static analysis, and generates QA report with quality score.

Verify implementation conforms to planning artifacts. Checks API routes against OpenAPI spec, schema against ERD, domain model against classes, acceptance criteria coverage, security implementation, and documentation completeness.

Synchronize planning artifacts with implementation status. Updates progress tracking, marks completed items in RTM, and generates progress reports. Use after completing implementation work.

Enforce architecture boundaries using dependency-cruiser and generate a dependency graph.

Synchronise work with Beads (bd). Ensure current work is tracked, linked, and committed as evidence.

Run deterministic browser QA using agent-browser. Produce QA report + trace/screenshot evidence.

Run the full local quality gate suite and write a merge-evidence report to reports/quality/.

Run a formal inspection-style review (Fagan) using a checklist, producing a merge-blocking review record.

Run security scans and write a security evidence report.

Write correct @spec JSDoc annotations in TypeScript/JavaScript source files to link code to specgraph spec documents.

Analyse specgraph verify output and identify what evidence is missing to advance specs to their next state.

Write specgraph spec documents with correct YAML frontmatter, evidence requirements, and section structure.

Interpret the output of `specgraph verify` and explain what each status means and what to do next.

Write a specgraph evidence waiver for a spec requirement that cannot currently be satisfied, with a clear justification and expiry plan.

Load relevant codebase context based on task type. Trigger this skill when starting any task that involves understanding or modifying the Beacon codebase, especially when working in an unfamiliar area.

Enforce architecture boundaries using dependency-cruiser and generate a dependency graph.

Run the full local quality gate suite and write a report to reports/quality/.

Run a formal inspection-style review using a checklist, producing a review record.

Run a Fagan Inspection and create Beads issues from the defect log. Use when the user wants a structured findings-first review plus actionable Beads tracking for the resulting defects. Converts defects into trackable Beads tasks with priorities, structured fields, and parent-child dependencies.

Formal defect-finding inspection of the current change set using Fagan steps. Use when the user asks for a Fagan inspection, deep review, code review, defect review, regression review, or a structured findings-first assessment of a diff, branch, staged changes, PR, or working tree. Uses parallel domain reviewers when supported and outputs a consolidated defect log plus verification.

Run a Fagan Inspection and create Beads issues from the defect log. Requires the fagan-inspection skill for the core review; this add-on converts defects into trackable Beads tasks with priorities and dependencies.

Run a formal Fagan Inspection on the current change set with (if available) parallel domain reviewers and a single consolidated defect log + verification.