The 87 skills that made the cut.

Returns a prompt in the model's exact syntax, with camera movement, lighting, scene pacing and compatible technical vocabulary — ready to paste into the tool.

Generates instructions for animating a still image with motion direction, speed and preservation of the original frame's visual identity.

Produces a reference panel of the character from several angles (front, profile, back), with facial expressions and props — the visual base for keeping consistency across every scene in the project.

Creates a photorealistic reference panel with variations in lighting and face angle, ideal for keeping a real person's identity consistent across video sequences.

Delivers the full pipeline in three documented stages: (1) the character sheet, (2) the generated scene reference frame, (3) the final video prompt — chained together and ready for production.

Analyzes the existing prompt, identifies the weak points (ambiguity, missing camera direction, conflicting style) and returns a corrected version tuned for the target model.

Sets up the whole infrastructure: connects the cloud GPU (Modal/RunPod), defines the storage bucket, picks the default ElevenLabs voice and checks the toolkit's dependencies.

The central entry point — creates a new video project with its folder structure and timeline, or lists existing projects to pick up again. Sets the title, description and starting template.

Opens Remotion Studio in the browser for frame-by-frame visual inspection of each scene, with timeline controls, zoom and before/after comparison of design revisions.

Focused on the visual refinement of one scene: it adjusts the color palette, typography, entry and exit animations, transition effects and visual assets until the scene reaches production quality.

Creates or loads visual identity profiles (hex colors, fonts, logos, preferred voice) that then apply automatically across every scene and future project.

Lists the available templates (sprint-review, product-demo) with a structural preview, or creates reusable templates from the current project to standardize future work.

Sends the script to ElevenLabs, returns an MP3 with the AI narration and syncs the audio to the Remotion timeline — including entry markers for each scene.

Replaces an existing video's audio track with a new narration or cloned voice, keeping automatic sync with the original visual elements.

Guides the recording of voice samples (30 seconds minimum), trains the model on ElevenLabs and saves the named profile for use in every future project.

Uses Playwright to record interaction with any site or app in the browser automatically, producing a demo video ready to edit in the toolkit.

Manages the toolkit's sub-skills: installs individual components (remotion, ffmpeg, elevenlabs, ltx2…) or creates new custom skills for specific flows.

Checks the versions of every installed dependency and flags which ones need updating, to avoid conflicts and keep the tools compatible.

Installs the full bundle of 21 skills into your agent (Claude Code, Cursor, Gemini CLI, Codex) — after that you just describe the video you want in plain language.

Creates a new video project with the HTML composition structure ready to go: timeline, tracks and a working example to edit.

Opens the preview in the browser, reloading on every edit — you see the composition exactly as it will render, frame by frame.

Renders the HTML composition to MP4 through Headless Chrome and FFmpeg. The output is deterministic: the same input always produces the same video.

Generates a product launch video of up to about three minutes: visual script, animated scenes, transitions and feature highlights.

Converts an existing site into a promotional video: it captures the sections, animates the elements and assembles the visual narrative on its own.

Turns a pull request into a changelog video: it summarizes the changes as animated scenes, ideal for release notes in video form.

Creates explainer videos with no presenter on screen: animated typography, diagrams and motion graphics carry the narrative.

Generates video synced to a music track: cuts, animations and effects land on the beat.

The agent clones the repo and links it into your skills directory itself. You can also use npx skills add Vincentwei1021/video-shotcraft or create the symlink by hand.

209 previews with search and filters, and the card name to copy. Picking the shot in the gallery before you start saves the round trip of describing motion in words.

A validated template: 1920×1080 at 30fps, ten shots in a paper-ink-amber look, with a 2.5D camera over a real page, title cards, transitions and a pinned sound pass. The agent swaps in your captures, copy and branding.

The cards sit in ten functional categories. With no card specified, the skill introduces the built-in template first and asks whether you want it.

Each card has a TSX implementation carrying the real easing and timing parameters, deterministic and driven by normalized progress — so you can adapt it without breaking the motion.

149 effects across 16 categories: transition, impact, riser, camera, UI, text, paper, film, light, data, sci-fi, mech, glass, fluid, crowd and counter. Five BGM options come along.

On a low-core machine concurrency fails above 2; recent Chrome dropped the old headless mode, so point it at chrome-headless-shell; and if Remotion's CDN is unreachable, the automatic download is refused.

After delivery the film becomes an editable draft: each shot cut separately for retiming and grading, captions rebuilt as native text tracks, effects and music on separate audio tracks. Verified on JianYing Pro 11.2 for macOS.

For a script with finished voiceover: word-level timing aligned locally, 78 motion recipe cards, and a seven-layer system against the slideshow effect.

Triggers the full five-phase creative cycle: brief → 3 consumer insights → 8-12 concepts across varied methodologies → ranking with a Cannes/D&AD score → refinement of the top concept until it reaches 9+.

Returns 3-5 strategic insights about the category using 7 mining techniques (Mark Pollard, JTBD, tension mapping), each stated as a real, actionable human tension.

Scores the concept on 6 weighted criteria (originality 25%, strategic fit 20%, emotional response 20%, feasibility 15%, scalability 10%, simplicity 10%), with the reasoning stated per criterion.

Generates 5 social concepts with format, suggested platform, main hook and engagement potential — ready to brief a production team or content creator.

Develops a central idea platform with creative territory, tagline, brand manifesto, 3 activations across different channels and the criteria for judging future executions.

Runs 6 lateral thinking provocations to break the problem's frame, producing unexpected connections and non-obvious angles — the antidote to linear thinking.

Delivers a complete article: meta title and description, a Key Takeaways box, H2/H3 sections written answer-first, sourced statistics, a hero image, 1-2 SVG charts, an FAQ section, JSON-LD schema and E-E-A-T signals.

Analyzes the existing file, replaces unsourced statistics, applies answer-first formatting, updates dates, adds missing images and charts, injects FAQ schema and strengthens E-E-A-T signals.

Returns a report with a 0-100 score across 5 categories, a list of problems by severity (critical/medium/low), detection of AI patterns in the text, and prioritized recommendations.

Delivers a complete brief: primary and LSI keywords, personas, search volume, a detailed outline, 5 recommended statistics, image and chart suggestions, and a multichannel distribution plan.

Generates an H2/H3 structure from a SERP analysis of the top 10 results, with the content gap identified, a word count per section and markers for where image and chart go.

Delivers a strategic plan with 20+ topics in hub-and-spoke clusters, an opportunity versus difficulty map, an analysis of AI coverage and a suggested publishing calendar.

Plans a semantic cluster around a seed theme — pillar article plus supporting spokes — and, with execute, writes the cluster's posts with cross-links back to the central pillar.

Generates a monthly or quarterly editorial calendar with publishing dates, topics, recommended templates, seasonal windows and refresh posts for existing content in decay.

A pass/fail checklist covering: title tag (length plus keyword), meta description, heading hierarchy, keyword density, internal and external links, Open Graph, Twitter Card and URL.

Generates a complete JSON-LD block with BlogPosting, Person, Organization, BreadcrumbList and FAQPage types, validated against Google's requirements and ready to drop into the page head.

An AI citability score (0-100) with analysis of quotable passages, Q&A formatting, entity clarity, structured data and accessibility for GPTBot and PerplexityBot.

Adapts the post into 5 formats: a Twitter/X thread, a LinkedIn article, a YouTube script, a Reddit post and a newsletter snippet — each with the tone and structure the platform expects.

Finds free images (Pixabay/Unsplash/Pexels) or generates original ones through Gemini with an optimized six-component prompt — returning the URL, SEO alt text and embed code.

Generates an MP3 with TTS narration (30 voices, 80+ languages) or a podcast version with two voices in dialogue — returning the HTML5 embed ready for the post.

Sweeps every post on the site in parallel with subagents, returns individual scores, detects orphan pages, keyword cannibalization and content in decay — with a prioritized action queue.

Detects posts competing for the same keyword or search intent, rates the severity (high/medium/low) and recommends a merge, a differentiation or a 301 redirect for each case.

Fetches every URL cited in the post and checks whether the stated statistic actually appears in the source (exact match, paraphrase or not found), returning a confidence score per claim.

Queries your Google NotebookLM notebooks and returns answers grounded in the documents you uploaded, with source citations — Tier 1 data for feeding articles and fact-checking.

Creates or applies a writing persona with 4 tone dimensions (the NNGroup framework), Flesch readability targets, sentence length and vocabulary — to hold the editorial voice steady.

Creates the BRAND.md and VOICE.md context files — positioning, editorial guidelines and brand voice — which every sub-skill loads automatically in each writing flow; show displays them and update refreshes them.

Suggests tags and categories from the content (with a minimum post-per-tag threshold) and syncs them through the WordPress, Ghost, Shopify or Strapi API automatically.

Reaches 13 Google services through their APIs: PageSpeed Insights, Core Web Vitals (25 weeks of history), Search Console, GA4 organic traffic, NLP Entity Analysis, Keyword Planner and the Indexing API.

Ask Claude Code to install the skill straight from the repository — it downloads the SKILL.md and the reference files (phrases, structures, examples) into the skills folder.

Rewrites the text, cutting banned phrases, structural clichés and the passive voice — returning a more direct version that reads as human.

Rates the text from 1 to 10 on each of the 5 dimensions and returns the total out of 50 — under 35 means it needs another pass.

Produces a diagnosis of which banned phrases and structural clichés show up in the draft, without rewriting — useful for a manual revision.

A surgical pass: converts everything to the active voice and removes preambles and commentary about the text itself.

Installs the skill through the skills CLI; with --agent '*' it installs into every agent detected on the machine at once.

Registers the repository's marketplace in Claude Code; then run /plugin install humanizer@humanizer to install it as a plugin.

The main command: it checks the text against the 33 patterns, rewrites the passages it detects and returns the version without the AI signals.

The plain-language alternative — useful in agents without slash command support, or when the skill is installed as a loose SKILL.md.

The voice calibration flow: samples of your writing act as the reference and the rewrite comes back in your style, not a generic neutral one.

Updates the skill to the repository's latest version — the patterns get revised as the Wikipedia guide evolves.

Installs the skill by cloning the repository straight into Claude Code's global skills folder — from then on it activates whenever you ask for text to be humanized.

The documented alternative for agent environments that read skills from ~/.agents/skills/ rather than the Claude Code folder.

Triggers the skill in plain language: it rewrites the text, removing the 25+ AI patterns, and returns a version that sounds human without changing the meaning.

A documented trigger variant — it focuses on cleaning up the patterns (connectives, crutches, promotional tone) while keeping the text's original structure.

The third documented trigger: it targets the mechanical tone and the formulaic sections, returning fluid prose in Portuguese.

Then /plugin install banana-claude@banana-claude-marketplace. Requires Claude Code 2.1.199 or newer, Python 3.11+ on PATH, and a Gemini key on a billing-enabled Google project.

The plugin installs disabled precisely because it costs money. After enabling, run /reload-plugins.

It plans offline first. Read the plan — prompt, references, privacy settings and estimate — and only approve when it matches your intent.

The edit path is built to make one clear change while preserving identity, geometry and brand detail — the opposite of regenerating and hoping.

A bounded portfolio, so you choose on evidence rather than instinct. The routes run across Nano Banana 2 Lite, Nano Banana 2 and Nano Banana Pro.

Checks copy, crop, composition, consistency, artifacts, rights and provenance. The project is explicit: generated output is never treated as automatically correct or production ready.

When the wording has to be exact, the copy, fonts, logos and art are composited locally rather than trusted to the model — which misspells by nature.

An old public install may have left an unpinned third-party MCP entry, a raw Google key in settings, or an obsolete directory. v3 ships a scan and cleanup — and rotate any key that sat on disk or in shell history.

Delivers the landing page's complete code with an automatic design system for the niche (palette plus typography), hero/features/pricing/CTA sections, responsive components and a UX quality checklist.

Produces a dashboard layout with sidebar, header, a grid of metric cards, 2-3 charts of the type best suited to the data, paginated tables and dark mode — all on a consistent color system.

Generates a portfolio with the palette and typography chosen by the style, a responsive project grid, an about section, CSS entry animations and code ready to deploy.

Delivers the app's main screens (home, product, cart, checkout) with mobile navigation patterns, touch-friendly components, 44px spacing and iOS/Android accessibility guidelines.

Builds an admin panel with a collapsible sidebar, a header with breadcrumbs, tables with filters and pagination, CRUD forms and a visual representation of permissions.

Analyzes the market segment and returns: a palette grounded in the sector, 2 recommended typographic pairings, the dominant visual style and the UX patterns specific to that industry.

An audit covering: WCAG accessibility score, contrast problems, broken visual hierarchy, spacing inconsistencies and corrected code with explanatory comments.

Delivers a shadcn/ui component with typed TypeScript, variants from the chosen theme, accessibility (aria labels, focus-visible), hover/focus/disabled states and prop documentation.

Clones the repository with the 73+ DESIGN.md files and their previews, so you can pick a reference brand and copy the file into your project.

The agent reads the palette, typography, spacing and component styling from the file and generates an interface aligned with the brand's visual language.

Refactors existing components to follow the color, font, spacing and shadow rules defined in the brand's design system.

Returns the design tokens in structured form (hex values, type scales, font weights) ready to use in CSS or in the Tailwind config.

Installation through Claude Code: ask it to install the skill from the repository and it configures UI/UX Pro Max, Framer Motion and 21st.dev in one go.

Manual installation (Mac/Linux): clones the repository straight into Claude Code's commands folder.

Generates a complete, responsive landing page with automatic palette and typography, 21st.dev components and Framer Motion animation — ready to publish.

Assembles a portfolio with a project grid, scroll entry animations and hover effects, using ready-made components and a coherent design system.

Adds a hero section based on a 21st.dev component with a Framer Motion entry animation — ideal for lifting an existing page.

Installs every skill in the repository through the skills CLI — from then on the AI applies the taste rules automatically when generating frontend.

Installs one specific skill (the default v2, gpt-taste, brutalist-skill and so on) rather than the whole bundle — useful for keeping just the style variant you want.

Generates the frontend with the three dials calibrated: variance 8 (asymmetric, modern layout), motion 6 (animated scroll plus hover) and density 4 (visual breathing room). Change the numbers to change the character of the design.

Triggers the redesign-existing-projects skill: it audits the current interface, points out where the slop is and rewrites the components against the taste rules, keeping the functionality intact.

Uses the image-to-code pipeline: it first generates a reference image of the design (imagegen) and then converts it into component code faithful to that visual reference.

Applies a specific style variant (brutalist, minimalist or soft) to the page, keeping the same dial system but with a defined visual language.

Installs the skill into the agent of your choice (Claude Code, Cursor, Copilot, Gemini CLI…) with native hooks for editor integration.

A guided interview that documents the project's design context and generates PRODUCT.md and DESIGN.md — audience, brand, voice and components that every other command then respects.

Builds a new interface or feature with design direction already applied, avoiding the generic patterns AI tends to repeat.

An honest, specific critique of the current design: it names what is generic, dated or inconsistent with the DESIGN.md, with actionable suggestions.

A full audit of the interface against the 45 detection rules: typography, contrast, spacing, animation and tap accessibility.

A final refinement pass: micro-adjustments to spacing, alignment, transitions and hover states that lift the perceived quality.

Raises the design's visual intensity (contrast, scale, color). Its opposite, /impeccable quieter, calms an interface that is doing too much.

Opens live experimentation mode in the browser: you iterate visually over the interface and the agent applies the adjustments in real time.

Runs the standalone detector with its 45 deterministic rules — no API, ideal for CI/CD: it fails the build when it finds design anti-patterns.

Registers the main collection's marketplace in Claude Code. The sibling collections (Owl-Listener/inclusive-design-skills, for instance) register the same way.

Installs the research plugin. The author's recommended starting set: design-research, ux-strategy, ui-design and design-ops — each installed with the same command pattern.

Runs a complete user research discovery cycle; its siblings :interview and :synthesize prepare interviews and turn the data into insights.

Turns an ambiguous challenge into a clear problem statement — the starting point of the flow for new products.

Designs a screen's full layout; /ui-design:color-palette generates the palette with accessibility checks and :type-system handles the typography.

Designs a complete interaction flow with states and movement; :map-states and :error-flow detail the state machines and error paths.

Extracts and organizes the project's design tokens; :create-component produces complete component specifications and :audit-system audits consistency and accessibility.

Generates the development handoff package — specs, assets and context ready for implementation.

Runs the seven visual critiques (hierarchy, brand consistency, composition, typography, affordance…) over a screen and returns a prioritized list of fixes.

Installs the complete collection into the current project through the skills CLI.

Installs only the skill you choose; combine it with --global for a global install or -a claude-code to target a specific agent's directory.

Registers the marketplace; then install the packs with /plugin install — web-design-skills, presentation-skills, knowledge-base-skills or image-generation-skills, all @garden-skills.

Updates every installed skill to its latest version; npx skills list shows what is installed and npx skills remove uninstalls.

The pinned release route: download the zip of the exact version, check the SHA-256 and unpack it into .claude/skills/ — for anyone who needs reproducible builds.

A basic extraction with nothing to install: it analyzes the site and returns the complete design system — colors, typography, spacing, shadows and motion. --save-output writes the result to disk; --json-only emits the JSON alone.

Exports the tokens in the agent-readable DESIGN.md format — drop the file in the project root and ask for on-brand UI (the same standard Awesome Design MD in this catalog consumes).

Exports in the W3C Design Tokens (DTCG) standard — interoperable with Figma/Tokens Studio, Style Dictionary and the Tailwind config.

Runs the WCAG audit with real contrast checking against the rendered DOM, grading every color pair AA/AAA and naming the failures.

Analyzes several pages at once (up to 10) by crawling the DOM; the --sitemap alternative discovers pages through sitemap.xml, and specific paths can be passed directly (/pricing /docs).

Compares the current extraction against a saved baseline and reports the design drift — the official GitHub Action fails the build on a deviation; --approve accepts the current state as the new baseline.

Generates a PDF summary of the design system — brand documentation ready to share with the team. Other variants: --dark-mode extracts the dark version and --mobile uses a phone viewport (390x844).

Registers the MCP server in Claude Code: the agent gains 11 tools (get_design_tokens, get_color_palette, compute_drift, export_dtcg…) for querying any site's tokens right in the conversation.

Installs Motion for React and JavaScript projects — import from motion/react or use animate() straight from the motion package.

Installs Motion's official Vue package, with the same API for springs, gestures and layout transitions.

The AI Kit's interactive installer (it needs Motion+ and an API key): it sets up skills, an MCP server and documentation access in Claude Code, Cursor, Windsurf, Gemini CLI, Copilot and others.

A documented AI Kit example: the agent returns the spring's physics as a ready CSS linear() curve (600ms linear(0, 0.0121…), for instance) — physics-based animation without loading a library at all.

Installs the chosen component straight into the codebase through the shadcn registry — the suffix picks the variant (TS-TW = TypeScript + Tailwind; JS-CSS = JavaScript + plain CSS).

The alternative route: jsrepo downloads the component in the variant named in the reactbits.dev registry URL into the project folder.

Every component shows its complete code on the site — copy the variant you want and paste it into the project; dependencies, where they exist, are listed on the component's page.

With the library in the project (or the code pasted in), the agent integrates the component, adjusts the props (duration, delay, easing) and matches the colors to your design system.

The recommended install: it downloads the 8 skills into the detected agent's skills folder (Claude Code, Cursor, Codex and others).

The same install, aimed explicitly at one agent — in the example, Google Antigravity.

Registers the repository as a plugin marketplace in Claude Code, so you can install the skills as a plugin. In Copilot, the alternative is copying .github/copilot-instructions.md into your repository.

Installs the skill by cloning the repository straight into Claude Code's skills folder (it also works as a git submodule under the project's .claude/skills/).

Generates the hero section with an Apple-style fade and slide entrance, in TypeScript/JSX with the spring physics configured.

Implements a multi-speed depth effect using useScroll and useTransform, tied to the scrollbar.

Creates the card component with its hover interaction (elevation and shadow) through the whileHover mechanic.

Delivers a drag-reorderable list using the FLIP technique and AnimatePresence — the items slide into their new position.

Implements the magnetic effect: the button leans gently toward the cursor as it approaches.

Installs the complete pack through the skills CLI — the guide skills (design, vocabulary, Apple) then activate contextually while the agent works on UI.

Triggers the improve-animations skill's full audit: it sweeps the codebase across 8 categories and returns findings ordered by impact.

Quick mode: a single pass over the highest-impact animation problems rather than the full audit.

Audits a single category (performance, in the example) rather than all 8 — useful for focusing on one kind of problem.

Generates a self-contained implementation plan for one specific improvement — with enough context to be executed without design judgment.

Executes a previously generated plan — the plans are written so a cheaper model can implement them without needing taste or extra context.

Registers the repository's marketplace in Claude Code — the first step before installing any plugin or bundle from the collection.

Installs the core 3D and animation bundle (threejs-webgl, gsap-scrolltrigger, react-three-fiber, motion-framer, babylonjs-engine). Other bundles: extended-3d-scroll, animation-components, authoring-motion, meta-skills — or install individual plugins by name.

Generates a ready Three.js scene setup — it also answers prompts such as "Create a Three.js scene with PBR materials".

Creates scroll-driven GSAP animation; its sibling /gsap-scrolltrigger-timeline_builder assembles complex timelines.

Generates React Three Fiber components in 12 different types, with physics and boilerplate ready.

Builds Framer Motion animation across 11 pattern types, ready to paste into the component.

Generates Babylon.js scenes in 8 types; /babylonjs-engine-mesh_builder builds 3D meshes in 13 shapes.

Builds 2D particle systems with PixiJS — for background effects, transitions and interactive detail.

Optimizes Blender 3D models for the web; the sibling commands -batch_export and -generate_lods handle bulk export and levels of detail.

Assesses the page against modern web design criteria — the collection's audit meta-skill.

Clones the repository and copies the .claude/skills directory into your project — Claude Code then detects all 10 skills.

The alternative route: adds the repository as a project submodule — a git submodule update pulls in future revisions of the skills.

The fundamentals, materials and lighting skills load together: the agent assembles the scene, camera and renderer and configures MeshStandardMaterial with correct shadows.

Triggers loaders and animation: GLTFLoader with the correct async pattern, a configured AnimationMixer and the right clip on loop.

Triggers the postprocessing skill: EffectComposer with RenderPass plus UnrealBloomPass, with the threshold and strength parameters explained.

The recommended install through the skills CLI — the skill is then detected automatically on animation tasks, with no slash commands.

The manual route: clone the repository and copy the skill's folder into Claude Code's global skills directory (in Cursor, the destination is ~/.cursor/skills/).

Triggers Create mode: the skill picks a motion cookbook pattern, easing and duration suited to the context, with AnimatePresence and prefers-reduced-motion handled.

Builds the component from scratch with the movement decided by the lenses — in a dashboard, the restraint lens weighs more and the motion comes out fast and discreet.

Audit mode: it sweeps the existing animation, flags missing movement and AI slop patterns, and returns a self-contained HTML report with CSS demos — or markdown with --terminal.

A focused audit: it reviews only the named component's animation against the checklist (bare easing, initial scale(0), decorative by default) and suggests the fixes.

The only documented installation route — distributed through skills.sh, compatible with 40+ agents (Claude Code, Cursor, Codex, Copilot).

The skill maps the emotion you asked for ("playful") to concrete timing, easing and choreography parameters, and implements it in the project's library.

Uses the state feedback patterns: it designs the button's state machine with continuous, legible transitions between the three states.

Applies the choreography strategies: entrance order by visual hierarchy, relative timing between elements and coordination without stagger-spam.

Assesses the existing code against the quality checklists and reference tables, naming the durations, easings and property choices to correct.

The recommended route in Claude Code: register the repository's marketplace; then run /plugin install scroll-world@scroll-world to install the skill.

Installs through the skills CLI into the detected agent — with -a codex (or another) the install targets one specific agent out of the 20+ supported.

The manual route: clone the repository and copy the skill's folder into Claude Code's skills directory (in Codex, the destination is ~/.codex/skills/).

Invokes the skill in Claude Code — in other agents, use $scroll-world (Codex) or browse the installed skills with /skills.

The skill generates each scene's diorama, the cut-free transition videos and the page where scroll drives the camera flight — describe the scenes and the visual tone you want.

Generates the native portrait variant for phones — the scenes are re-rendered at 9:16, preserving the composition rather than cropping the original format.

Creates the test suite from scratch: it generates the config, example tests and a CI workflow, and installs the three browser binaries.

Runs every test in parallel across the configured browsers, with auto-waiting and automatic assertion retries.

Opens the recorder: you interact with the page in the browser and Playwright generates the test code with resilient locators automatically.

Opens UI mode with a timeline, watch mode and step-by-step visual debugging of every action in the test.

Opens the Trace Viewer with screenshots, DOM snapshots, network requests and console messages for every step — ideal for investigating failures.

Downloads and installs (or updates) the Chromium, Firefox and WebKit binaries the tests use.

Opens the last run's HTML report with results per test and browser, plus screenshots of the failures.

Installs the Specify CLI, the command-line tool that initializes and manages spec-driven projects.

Creates the .specify/ structure in the project and asks which AI agent to use (choose Claude Code) to receive the slash commands.

Creates the governance principles and quality standards that guide every later phase of the project.

Defines functional requirements and user stories focused on the what and the why, without fixing a technology or stack.

Resolves underspecified areas and ambiguities in the spec before moving on to technical planning.

Generates the technical implementation strategy, including architecture decisions and the technology stack.

Breaks the plan into tasks ordered by dependency, with parallel execution markers and a TDD structure.

Executes every task systematically, in dependency order, writing the code for each one.

Validates cross-consistency between spec, plan and tasks, naming conflicts and gaps before implementation starts.

Assesses how complete the code is against the spec and the plan, identifying what is still missing.

Converts the generated tasks into GitHub Issues, dependencies included, for team tracking.

Generates custom quality validation checklists for reviewing deliverables against specific criteria.

Activates the skill at the chosen intensity — lite (light suggestions), full (the default) or ultra (maximum minimalism). Use /ponytail off to turn it off.

Analyzes the current diff for over-engineering: unnecessary abstractions, code that already exists in the project, and problems the standard library would solve.

A full audit of the repository: it maps duplication, redundant dependencies and code that can be removed or simplified.

Collects the items deliberately deferred in the name of simplicity, so you can decide when — and whether — they are worth building.

Shows the skill's impact for the session: lines avoided, tokens saved and the estimated gain in cost and speed.

A quick reference for every command, the intensity modes and the seven-level decision ladder.

A one-step install through Claude Code's official plugin marketplace — the recommended route.

Registers the project's own marketplace; then run /plugin install superpowers@superpowers-marketplace to install.

Installs the plugin in Cursor with a single command.

Registers the marketplace in the Copilot CLI; then run copilot plugin install superpowers@superpowers-marketplace.

Installs the plugin in Google Antigravity straight from the repository.

Installs into the Pi agent. Also documented: Codex (app and CLI through /plugins), Kimi Code (/plugins install) and OpenCode (the repository's INSTALL.md).

Installs the complete collection through the skills CLI — it works in Claude Code, Cursor, Codex, OpenCode and the other agents the format supports.

Installs only the chosen skill rather than the whole pack — useful for bringing in just the React performance rules, for instance.

Fires react-best-practices: it audits the component against the Vercel engineering team's rules on waterfalls, bundle size and rendering, with suggested fixes.

Fires web-design-guidelines: it runs the interface code through the 100+ rules — accessibility, forms, animation, images, dark mode and i18n.

Fires writing-guidelines: it audits the documentation against the 80+ rules in Vercel's writing manual — clarity, consistency and tone.

Fires vercel-deploy-claimable: it detects the framework (40+ supported), deploys instantly to Vercel and hands you the link to claim ownership of the project.

Installs the full set through the open skills CLI, which covers Claude Code, Cursor, Codex, Copilot, Cline and others. Use --list to pick first.

Registers the marketplace; then /plugin install agent-skills@addy-agent-skills installs the bundle. On SSH errors, use the full HTTPS URL.

Turns an idea into a specification. This is the stage most people skip and the one that accounts for most of the rework later.

Breaks the spec into tasks that fit in one head at a time. Large tasks are where the agent loses the thread.

Implements incrementally. With /build auto it generates the plan and runs every task in one approved pass — each still test-driven and committed separately, pausing on failures or risky steps.

Activates the test-driven development skill, with red-green-refactor enforced rather than suggested.

A review aimed at code health, not just correctness. Also available on its own: npx skills add addyosmani/agent-skills --skill code-review-and-quality.

Audits application performance starting from measurement rather than a hunch — the order that avoids optimizing something that was never the bottleneck.

Cuts accidental complexity. It is the counterweight to /build: building fast accumulates cleverness that has to be undone.

Installs general audit, performance, Core Web Vitals, accessibility, SEO and best practices.

Walks the Lighthouse categories cross-referenced against the source, instead of reporting only the score.

Separates field from lab and points at the real phase of the problem — load, delay or paint.

Identifies the LCP element and the phase dominating the time, which is the step before any optimization.

Finds the elements that shift and where it comes from — an image with no dimensions, a font swapping, injected content.

Checks conformance, keyboard navigation and screen reader support, with the standard as the reference.

Covers crawlability, indexing, meta tags and structured data against current search guidance.

Points at security patterns, modern API use and code quality in the web layer.

It is in the official Claude Code marketplace, so there is nothing to add first and updates arrive on their own. You subscribe rather than fork.

An alternative to the terminal command, for when you are already mid-session.

Copies the files into the project, and then they are yours. The installer lets you choose which skills to take and which agents to install them on.

Lists the available skills so you can choose before copying. Installing both ways at once leaves you with everything duplicated.

The skills were written to be modified. Copying without adapting wastes the main advantage over a closed framework.

Then just ask the agent to install it in the repository: it copies the plugin, installs current Oxlint dependencies, merges into the existing lint configuration, enables every generic rule and validates the result.

Lists what the package ships, so you can decide before it touches the project configuration.

The path for people who would rather not let the agent touch the configuration. You then have to register the entry point in oxlint.config.ts.

Goes inside defineConfig in oxlint.config.ts. It is worth ignoring the agent directories (.claude, .cursor, .codex and friends) in ignorePatterns.

The skill enables this group on its own when it detects the repository depends on Effect; in a manual install it is enabled separately.

The project is made to be vendored, not followed blindly. A rule that makes no sense in your context should go.

Registers the marketplace; then /plugin install compound-engineering installs the 33 skills.

In Cursor Agent chat. The same account serves Grok Bot, which uses the Cursor plugin library.

Running /plugin update on its own keeps you on the old version — you have to refresh the marketplace first.

Opens the problem before closing on a solution, which is where the loop begins.

Turns the chosen direction into an executable plan, with the decisions on record.

A review inside the same loop, with access to the context of what was planned.

Writes the knowledge where the next change reads it. Skipping this turns the method into an ordinary process framework.

Then /plugin install andrej-karpathy-skills@karpathy-skills. The README still names the old owner, forrestchang, because the repository changed hands — GitHub redirects the old path.

In a project that already has a CLAUDE.md, use >> to append instead of -o, which overwrites the whole file.

State assumptions out loud, present the interpretations when there is ambiguity, push back when a simpler path exists, and stop when confused — naming what is unclear.

Nothing beyond what was asked, no abstraction for single-use code, no unrequested flexibility, no error handling for impossible scenarios. If two hundred lines fit in fifty, rewrite it.

Do not improve adjacent code, do not reformat, do not refactor what is not broken. Dead code you notice gets mentioned, not deleted. Remove only what your own changes orphaned.

Trade orders for success criteria. Instead of asking for validation, ask for tests on invalid input and make them pass. Strong criteria let the model loop on its own; weak ones require you at every step.

The repository ships a committed .cursor/rules/karpathy-guidelines.mdc, so the guidelines apply when you open the project in Cursor with no extra setup.

Installs the framework with every parser (MinerU, Docling, PaddleOCR) and optional feature — image, table and equation processing enabled.

Runs the end-to-end example: it processes the PDF through MinerU, builds the graph and leaves the document ready for multimodal queries.

Ingests the complete document: parsing, analysis of each modality (image, table, equation) and construction of the multimodal knowledge graph.

A hybrid query combining textual and graph retrieval, returning a grounded answer that draws on the document's text, tables and images.

A query that injects tables or images directly as context, with no reparsing — useful for asking about a specific passage already extracted.

Installs the tool (also through pipx or pip — the package is called graphifyy, with two y's). Optional extras: [pdf], [office], [video], [neo4j] or [all].

Registers the skill in your AI assistant (~/.claude/skills/graphify/). Use --project for project scope, or --platform codex/gemini for other agents.

Maps the whole folder and generates graph.html (an interactive visualization), GRAPH_REPORT.md and graph.json under graphify-out/. The --mode deep option extracts relations more aggressively.

Re-extracts only the files that changed (cached by SHA256) and merges them into the existing graph — no reprocessing everything.

Answers a plain-language question from the graph, instead of you grepping files for the connection.

Traces the chain of connections between two concepts in the graph — how a service reaches the database pool, for instance.

Explains one node: what it is and everything connected to it in the graph.

Fetches external content (an arXiv paper, a tweet, a YouTube video) and merges its concepts into the project's graph.

Builds a markdown wiki that agents can navigate, with one article per concept community detected in the graph.

Installs a post-commit git hook that rebuilds the graph automatically on every commit — the graph never falls behind the code.

Then /plugin install understand-anything. For privacy or enterprise setups you can point the platform at a local model, for instance through Ollama.

It saves to .ua/knowledge-graph.json. Mind the cost: the first sweep analyzes the entire codebase and burns a lot of tokens on a large project; later runs only re-analyze what changed.

An interactive web dashboard, color-coded by architectural layer, searchable. Click a node to see its code, its relationships and a plain-English explanation.

It answers from the graph already built, rather than re-reading the whole codebase for every question.

Analyzes how the current edits ripple through the rest of the graph — what breaks in the table you did not look at.

Writes the getting-started guide for new team members out of what the graph already knows about the codebase.

Swaps the structural view for a domain one: domains, flows and steps laid out in a horizontal graph, tying code to real process.

Analyzes a single subdirectory. /understand --auto-update installs a post-commit hook to keep the graph current on its own.

A deterministic parser extracts wikilinks and categories from index.md, then agents surface implicit relationships, entities and claims — turning the wiki into a navigable graph.

Clones the repository and installs the backend dependencies (FastAPI, Python 3.10+) with uv.

Installs the React plus Vite frontend dependencies.

OpenRouter gives access to every model on the council with a single key and a single bill — create the account, generate the key and save it in .env.

A convenience script that starts the backend and frontend together — then just open http://localhost:5173 and ask. The manual alternative: uv run python -m backend.main plus npm run dev.

Customizes the council: edit COUNCIL_MODELS and CHAIRMAN_MODEL with any model identifier available on OpenRouter.

Installs the English skills and the web search subagent in Claude Code (v2.1.0+). The repository also documents the routes for OpenCode (which needs OPENCODE_ENABLE_EXA=1) and Codex (a TOML config plus an install script).

Phase 1: it produces the research outline — the items to investigate and the data fields to fill — for you to review and adjust before execution.

Adds new items to the research list — useful when the initial outline missed angles you want covered.

Adds field definitions (columns) that each item will have to fill — price, release date, source, whatever your analysis needs.

Phase 2: it dispatches the web search subagents in parallel, one per outline item, filling the structured fields with what they find.

Compiles the collected data into an organized markdown report — the pipeline's final deliverable.

Then /plugin install last30days. Reddit, Hacker News, Polymarket and GitHub work with no setup; the first-run wizard unlocks X, YouTube and TikTok.

Works for Codex, Cursor, Copilot, Gemini CLI and the rest of the Agent Skills hosts. Drop the -g and it stays scoped to the current project.

It returns what the person actually did this month — posts, threads, commits, interviews — instead of a LinkedIn page from two years ago.

A side-by-side table of architecture, memory, security and best-for, with star counts pulled from the GitHub API on the spot, not from a stale post.

It sweeps Reddit category listings, the Hacker News front page and the Digg feed, the agent judges the nominations, and you get five to ten velocity-ranked topics, each with cross-source numbers and a ready-to-run follow-up.

Open roles and careers pages become cited evidence of a shift in focus. The report says what the hiring appears to signal, not what the roadmap will ship — that distinction is the project's own.

The health command runs every source and prescribes the exact fix: which key is missing, which CLI is off PATH, which cookie expired.

YouTube only needs yt-dlp; Bluesky, an app password. TikTok, Instagram, Threads, Pinterest and LinkedIn go through a ScrapeCreators key, with ten thousand free calls.

Makes the twenty-plus plugins available for individual installation. Codex reads the same marketplace, with no metadata of its own.

Lists the marketplace plugins by domain and installs the one you pick — you do not have to take all of them.

Reviews only what changed, cross-referencing git history to understand why it changed — more accurate than reading the diff in isolation.

Builds understanding of the codebase one function at a time, before looking for defects. Auditing without this step yields shallow findings.

Cross-references version-matched advisories, abandoned upstreams, publisher concentration and install scripts — the four vectors of dependency compromise.

Puts every finding through systematic verification with a mandatory review. This is the step that separates a useful report from noise.

Found one bug, now find its siblings. Vulnerabilities rarely appear alone — the same wrong pattern is usually repeated.

Identifies error-prone APIs, dangerous configurations and designs that invite misuse — defects that are not bugs, they are traps.

Creates and refines a Semgrep rule for the pattern you want to catch, and a sibling plugin ports the rule to other languages with test-driven validation.

Installs nine SKILL.md-compatible skills: local and managed pentesting, vulnerability remediation, CI scanning, and target-specific flows (application, web, API, OWASP Top 10).

Installs the executable. The first run pulls the sandbox Docker image on its own; results land in strix_runs/<name>.

Points the engine at the model you want. Accepts OpenAI, Anthropic, Google and others.

Runs the full cycle — reconnaissance, exploitation and validation — over local code, and writes the result with the PoCs.

Triggers the web application pentest flow, with the interception proxy and offensive kit pointed at the target.

Walks the ten OWASP categories with exploit validation, rather than a checklist.

Generates the fix and runs again to confirm it closed — the step most tools leave to the human.

Sets up per-pull-request scanning in GitHub Actions or an equivalent pipeline, stopping the vulnerability before production.

Picks the provider and model, asks for the key and tests connectivity on its own. Only skippable in delegation mode.

Reviews every working-tree change at once — the everyday command, before opening the pull request.

Uses merge-base, so it reviews only what the branch introduced, without repeating what came from main.

Useful for retroactively reviewing a change that already landed, or investigating where a defect came from.

Reviews full contents instead of the diff. This is the right mode for auditing an unfamiliar codebase or a directory with no recent change.

Delivers structured output for the agent to consume, rather than prose for a human to read.

A long review does not restart from zero when it drops — list the sessions and resume the one that matters.

OCR handles file selection and rule resolution, and your coding agent does the reviewing. No API key of your own required.

Creates or refreshes the isolated runtime. /seo doctor checks readiness without changing anything on the system.

Spawns up to fifteen specialists at once and returns a prioritized action plan, with a 0-100 score.

Question-based citability scoring, primary-source evidence on llms.txt and agent-friendly page checks.

It even catches schema deprecation, the kind of thing Search Console and Lighthouse do not surface.

Assesses experience, expertise, authoritativeness and trust with judgement, not as a checklist.

Delivers the detailed brief before writing, with the internal linking architecture already thought through.

Groups from what the SERP actually shows, rather than string similarity.

Stores snapshots in SQLite; then /seo drift compare shows what changed and /seo drift history the series.

Pulls real field and indexing data straight from the source, including a PDF report.

Exposes the data to Claude Code, OpenClaw or Hermes. This is the step that turns the tool into a source for the agent.

Skills are reusable workflows that guide the agent through SEO tasks using the MCP. You can write your own.

Pulls volume and difficulty through DataForSEO, charging only for what the query cost.

Monitors positions without the monthly subscription the traditional suites charge.

Surfaces what the competitor ranks for, to find the gap worth attacking.

A technical audit focused on workflow, without the reporting excess of the big suites.

Measures appearance in AI answers — the metric the classic tools still do not cover well.

Docker is for personal use on your own machine; for internet-facing access or team use the recommendation is Cloudflare, which works on the free plan.

Covers both fronts in one pass. It is the entry command when a site has never been looked at through the generative-search lens.

For deciding whether it is worth digging further, before spending time on the full audit.

Assesses whether the text is structured so the model can extract and cite it — which is what decides whether you appear in the answer.

Checks GPTBot, ClaudeBot, PerplexityBot and friends. An accidental block here makes everything else irrelevant.

Analyzes an existing one or writes it. Worth remembering that Google does not require llms.txt for its own AI features.

Sweeps mentions across the platforms models cite. Brand authority outside your own site shapes what AI says about you.

Engine-specific adjustments, rather than treating all generative search as one thing.

Closes the consulting loop: /geo report assembles the content and this version delivers the presentable PDF.

Gives the agent the four scripts of the flow and the ability to drive it in natural language.

Logs in through the browser and saves session cookies locally. You only repeat it when the session expires.

Creates or updates bio, employer and contact links. This is what the journalist sees when weighing the pitch.

Queries the request index and returns opportunities in the subject you actually know.

The agent chains search, drafting and sending. This is the intended way to use it, with the scripts underneath.

Drafts and optionally submits. It runs as a dry-run by default, so you can review before anything goes out.

Without the statistics page the pitch earns one citation. With it, it earns the citations of everyone who searches the topic later.

The recommended install through the skills CLI — it downloads the 50+ skills into the agent (Claude Code, Codex, Cursor, Windsurf). Also available as a plugin in the Claude Code marketplace.

Triggers the cro skill: it audits the page hierarchy, value proposition, forms and CTAs against established conversion frameworks — and returns the fixes in priority order, ready to apply.

Triggers the copywriting skill, which consults product-marketing first: the copy comes out grounded in the product's real positioning, audience and differentiator — headline, subhead, sections and CTAs.

Generates a complete B2B outreach sequence: an initial email personalized by segment, 2-4 follow-ups taking different angles, and guidance on subject lines and timing.

A technical and on-page diagnosis: indexability, URL structure, heading hierarchy, internal links, meta tags and Core Web Vitals — with a fix queue ordered by impact.

Applies the ai-seo skill: it reformats passages for LLM citability, entity clarity, structured data and accessibility to AI crawlers — marketing's GEO/AEO angle.

Structures the whole campaign: ad groups, keywords with match types, ad copy variations, extensions and budget and bidding recommendations.

Analyzes the current monetization strategy against proven SaaS models: tiers, value metric, price anchors and feature packaging — with reasoned proposals.

Assembles the full launch plan: phases (pre-launch, launch day, post-launch), channels, key messages per audience, the assets needed and an executable schedule.

Triggers marketing-council: it simulates a panel of specialists with distinct perspectives (growth, brand, product, sales) debating your question — useful for ambiguous strategic calls.

Then /plugin install claude-ads@ai-marketing-hub-claude-ads. The project warns: never pipe a remote installer straight to a shell.

Creates the client, account, indicator and guardrail profile. This is what defines what the system may and may not do afterwards.

A complete or scoped audit. Every finding carries the date of its evidence and a confidence level — no loose numbers.

Builds channel, campaign, budget, competitor and measurement plans from what the audit surfaced.

Produces the briefs and the assets. Creation lives in the same system that audited, so it inherits the account context.

Generates the campaign mutation plan without touching the account. /ads optimize --draft does the same for optimization.

Tracks pacing, delivery, tracking, creative fatigue, policy and performance in a single pass.

Designs the test or reads out one already run — the part that separates optimization from guesswork.

Shows where the operation stands and the highest-priority blocker right now.

Then /plugin install aaron-marketing@aaron. It also runs on 70-plus hosts through npx skills.

The same library, for Cursor, Codex and the other compatible hosts.

Goes from tracing the current narrative to evaluating it, through architecting and landing. Sixteen skills on that track.

Includes the deliverability QA skill, which is where a beautiful sequence usually dies in the spam folder.

Research, orchestration, activation and scale, with an account auditor at the end.

From the positioning map to the readiness auditor — the gate that stops you launching before you are ready.

Eight benchmarks feed eight auditors that emit structured verdicts. It is the mechanism that holds 120 skills consistent.

A quick snapshot of the site's marketing. Useful for showing value before proposing the full audit.

A broad analysis of the site, which is the base everything else produces from.

Delivers the rewrite next to the original, which makes the improvement demonstrable to the client.

Builds the full sequence with the progression logic between messages.

Monthly planning, which is the horizon social media is actually managed on.

Diagnoses the sales funnel and landing page conversion, with /market landing for the detail.

Gathers what competitors are doing, to position the proposal against the real market.

A professional PDF report. /market proposal generates the commercial proposal from the same material.

In claude.ai/settings/integrations, add an integration with this URL and a name of your choosing. Then authenticate with Pipeboard and connect the ads account.

Pulls the numbers at whatever level you ask, without opening Ads Manager.

Creates the campaign and the structure under it through conversation, using the CRUD tools the server exposes.

Changes spend without navigating the interface — useful when the adjustment is routine.

Searches and validates the targets before applying them, which is where campaigns usually go astray.

Sends the file and builds the ad with dynamic creative testing already on.

A local install requires creating a Meta Developer App. The remote path avoids that.

Goes in claude_desktop_config.json. On first use it prompts you to connect the Google and Meta accounts.

Puts spend and result in the same context, a cross-reference that normally takes two separate tools.

Pulls the research from the official source, with no data middleman.

Useful during a launch or a campaign spike, when the standard report lags too far behind.

Builds the audience on the platform, using the audience tools the server exposes.

Uses the Google Ads experiment tools to test with method, instead of changing something and watching.

Misconfigured attribution makes every media report lie — worth checking before drawing a conclusion.

The project has a hosted version and a self-hosted option; the quickstart covers the deployment path.

The dedicated CLI is the intended path for agents, rather than talking to the API by hand.

Publishes to Instagram, YouTube, LinkedIn, TikTok, X, Bluesky, Mastodon and Discord from a single schedule.

Closes the loop between publishing and knowing what worked, without leaving the tool.

The API was designed for automation, so scheduling can be triggered by any step of your flow.

Allows review and division of labour on the same calendar, which is where a single-user tool stalls.

Installs the CLI and library with every extra (proxy, mcp, ml, code, memory). It needs Python 3.10+.

Integrates automatically with a coding agent (claude, cursor, cline, continue) — the compression then happens transparently, without changing your flow.

Starts a drop-in HTTP proxy that compresses traffic to the LLM without touching your code — just point your app at the port.

Mines the sessions that failed, extracts the error patterns and writes corrections into CLAUDE.local.md or AGENTS.md so the agent stops repeating them.

Opens the metrics panel with token savings (input and output), compression rate and performance by content type.

Runs a health check on the installation: it verifies dependencies, the enabled extras and the compression configuration.

Registers the repository's marketplace in Claude Code — the first step of the recommended install.

Installs the plugin with all 17 skills. Thanks to progressive disclosure, the agent loads only names and descriptions — each skill's full content only enters the context when the task calls for it.

The no-plugin alternative: copy individual skills into the project's .claude/skills/ folder (or .cursor/skills/ and .codex/skills/ in the other agents).

Activates context-fundamentals: it maps the context's components (system prompt, tools, history, tool output) and points to where the low-signal tokens are.

Activates context-degradation: it identifies which failure pattern is at play (lost-in-middle, context poisoning, distraction, instruction conflict) and how to mitigate it.

Activates context-compression and context-optimization: it proposes the compaction, masking and caching that shrink the trajectory without losing the state the task needs.

Activates multi-agent-patterns: it compares the coordination patterns for your case, with the trade-offs in cost, latency and context fragmentation between agents.

Activates tool-design: it audits the tools' names, descriptions and schemas — ambiguous contracts are one of the biggest sources of wasted context and wrong calls.

Activates evaluation and advanced-evaluation: it assembles deterministic checks, scoring rubrics and an LLM judge with bias mitigation, to measure the agent's behavior reproducibly.

Registers the hooks and starts the service. Careful: npm install -g claude-mem installs only the library, without the hooks or the worker.

Then /plugin install claude-mem and restart. Context from previous sessions starts appearing on its own.

Swap opencode for antigravity depending on the agent. There is also an installer for OpenClaw gateways.

Returns a compact index of identifiers, at 50-100 tokens per result. It deliberately does not bring the content yet.

Shows what was happening before and after — the context is often worth more than the isolated observation.

Brings full content for the surviving identifiers, always batched. This is where the tokens go, which is why it comes last.

Search accepts filters by type, date and project, which keeps memory from another job out of the way.

Authenticates, generates the key and installs the skill. It lets you choose between CLI+Skill and MCP mode; --claude, --cursor or --opencode target one agent.

Appended to the request, it pulls the library's current documentation into context before the model answers.

The project's own example. The answer comes back with the current version's API, not the one from training.

It works without a key, but the request limit is lower. The key is free.

Registers the MCP server, and then the agent calls the documentation tools natively instead of going through the CLI.

Cleans up what was generated. If you installed the CLI globally with npm, that package is removed separately.

Then /plugin install context-mode@context-mode and restart. Requires Claude Code 1.0.33 or newer.

Validates runtimes, hooks, FTS5 and plugin registration. Every item should come back checked.

Shows tokens consumed and savings ratio per tool — the number that justifies having the plugin.

Puts the content into the FTS5 store, which survives the session and becomes queryable.

Searches what is already indexed, instead of the agent re-reading a whole file to find one line.

Slash commands are a Claude Code plugin feature. On other platforms, type ctx stats, ctx doctor, ctx index and so on.

Brings the new version, rebuilds, migrates the cache and fixes the hooks in one pass.

Permanently deletes all indexed content. Useful when switching projects or clearing sensitive data.

Installs the skill and the hooks. From then on the plan is re-injected every turn, without you asking.

Writes the initial task_plan.md. It is the file the hook will re-inject on every following turn.

Separating findings from plan matters: the plan says what to do, findings says what was learned along the way.

This is what lets you resume after a crash knowing exactly where you stopped.

Automatic recovery reads project files only. It is the use case the project is named for.

Reading local session records from the same project requires deliberately enabling catchup mode — it does not happen on its own.

The agent starts answering in clipped speech, but code, commands and errors stay exact. MIT, 30+ agents.

Shrinks what the agent reads before the provider call, with byte-exact recovery. Runtime under BSL-1.1, CLI under MIT.

Swap claude for codex, gemini, aider, opencode, hermes or openclaw depending on the agent you use.

The plugin path for people who only want Claude Code, without the full installer.

Wires up the Claude Code hooks and statusline, finds every supported agent on the machine, and is safe to rerun. Requires Node 18+.

Swap codex for your agent's profile. Works for Cursor, Windsurf, Cline and the other compatible ones.

Then install the plugins you care about, such as pm-toolkit@pm-skills and pm-product-strategy@pm-skills. In Cowork, all nine install at once.

The entry point when there is an idea but no validated problem yet.

Walks you through the strategic reasoning instead of asking you to fill in a canvas.

Builds the PRD with the framework's structure, not as a blank page with headings.

Sets the metric that steers decisions; /plan-okrs breaks it into objectives.

Covers the path to market, with the go-to-market and growth plugins.

Imagines the project already failed and asks why — the technique that surfaces risk optimism hides.

With /battlecard for the sales material and /pricing for the pricing strategy.

Look inward, look outward and reframe. It exists to stop the team from solving the wrong problem well.

Defines who you serve, what you solve and how you differ, in the established format.

Broad brainstorm, separation into allies, audiences and influencers, responsibility marking and an equity lens, narrowing to priority targets.

One grid sets engagement strategy, the other decides whose voice to elevate. The comparison is where the gap shows up.

Diagnoses profile and context and returns message framing, medium, cadence and a named next action.

Prepares the script so it does not lead the answer — the most common mistake in product interviews.

The full arc: positioning, problem framing, solution exploration and roadmap.

Market research, customer discovery, competitive analysis, brand, product definition, projections and validation experiments.

Builds from real reviews, forums and web data, delivering a feature matrix and pricing landscape.

A dedicated skill, separate from the full strategy, for when only positioning is open.

There is an explicit customer conversation gate. It is what separates validation from a writing exercise.

The tool was built to say the idea does not hold up when that is the case — and that is the most valuable output it can give.