Plugin-Skill-Studio

Plugin plugin-skill-studio in WinRecoveryProject/PluginMarketplace. Commands read from the repo's manifest — 10 days ago.

Skills (95)

• ai-data-remediation

  Self-healing data pipeline layer using semantic anomaly clustering, AST-validated lambda transformations, and zero-loss mathematical reconciliation. Use when data quality checks fail, anomalous records break ETL/ELT pipelines, you need automated data cleansing with sandboxed Python transformations,

• ai-engineering

  Design, train, optimize, deploy, and evaluate production machine learning and LLM systems. Use when building ML models, training classifiers, fine-tuning LLMs with LoRA/PEFT, deploying low-latency inference endpoints, architecting vector RAG pipelines, or evaluating model bias and data leakage — eve

• automate-ui

  Automates web and desktop UIs while capturing evidence that separates navigation from verified behavior. Use when a task requires site navigation, browser reproduction, or native app operation. For one existing framework-free HTML page, use design-ui instead.

• brainstorming

  Explores user intent, requirements, and design before implementation. Use when starting a new feature, component, or behavior change whose requirements or design are not yet agreed; skip for trivial single-file changes the user has already specified.

• brand-designer

  Use when a ChatGPT/Codex Plugin needs a production-ready visual identity and SVG logo system that clearly expresses the Plugin's job across light and dark surfaces.

• catalog

  Use when finding local skills or analyzing public directory snapshots, listing coverage and observed changes.

• code-review

  Review changed code against repository coding standards and original specification intent. Use when reviewing a branch, diff, PR, pull request, merge-base changes, or verifying code against documented standards — even if the user just says \"review this\". Do NOT use for authoring new code or diagno

• codebase-design

  Shared vocabulary and patterns for designing deep modules with narrow interfaces and clean seams. Use when designing module interfaces, finding deepening opportunities, deciding where seams go, or making code more testable and AI-navigable — even if the user says \"improve this module\". Do NOT use

• communicate-clearly

  Controls report length while preserving evidence and explains external sources without overstating them. Use when a user requests concise handoffs, set verbosity, or plain-language explanations of dense material.

• create-plugin

  Use when the user wants a new local or marketplace plugin candidate built from selected sources with provenance, compatibility and no-overwrite guarantees.

• create-skill

  Use when the user wants to create or update a Codex skill with scoped instructions, progressive disclosure, validation and no overwrite of upstream or installed sources.

• design-ui

  Builds accessible interfaces and verifies renders. Use when creating or redesigning a page, dashboard, or static HTML file.

• diagnose-systematically

  Finds root causes through reproduction and falsifiable experiments. Use when a failure, flaky behavior, or regression lacks a demonstrated cause.

• diagnosing-bugs

  Diagnose hard bugs, intermittent flakes, and performance regressions using a tight feedback loop. Use when the user reports broken behavior, runtime exceptions, failing tests, flaky CI, or says \"debug this\" / \"diagnose this\" — even if no error message is provided. Do NOT use for routine test-dri

• dispatching-parallel-agents

  Dispatches one subagent per independent problem. Use when two or more investigations or fixes can proceed concurrently without shared state or sequential dependencies.

• domain-modeling

  Build and sharpen a project's domain model, ubiquitous language, and architectural decision records. Use when establishing codebase terminology, challenging fuzzy concepts, writing ADRs, or updating CONTEXT.md — even if the user says \"define our terms\". Do NOT use for general code refactoring with

• engineer-prompts

  Builds or audits testable prompt contracts with explicit outcomes, permissions, tools, evidence, and stop conditions. Use when writing reusable agent prompts, system prompts, or prompts with unclear success criteria.

• engineering-workflow-guide

  Route engineering, AI/ML, cognitive, or productivity tasks to the narrowest effective specialist skill. Use when a task spans planning, implementation, debugging, review, architecture, research, setup, AI modeling, data remediation, or autonomous goals, when the user asks what to do next, or when un

• evidence-matrix

  Use when arranging explicitly supplied evidence by skill and source with an explicit snapshot date.

• execute-durably

  Runs long or interruption-prone work from a durable state file with falsifiable criteria and evidence. Use when work spans turns, risks compaction, or must resume after interruption.

• executing-plans

  Executes a written implementation plan inline, task by task, stopping only on blockers. Use when a plan exists and subagent dispatch is unavailable, or the user wants the plan executed in a separate session.

• experience-architect

  Use when a set of candidate Skills or app capabilities is technically valid but still needs to become a clear, useful ChatGPT/Codex Plugin that people can understand, discover, and invoke for real work.

• finishing-a-development-branch

  Guides integration of a finished branch: verify tests, present merge/PR/keep/discard options to the user, and clean up worktrees. Use when implementation is complete, all tests pass, and the work needs to be integrated.

• git-safety-guardrails

  Safeguard repositories against destructive, irreversible, or history-rewriting Git operations. Use when running force pushes, hard resets, branch deletions, cleans, destructive restores, or history re-writes — even if the user says \"clean up git history\". Do NOT use for routine safe git status, fe

• goal

  Design and synthesize high-leverage autonomous goal prompts and contracts for unattended execution. Use when crafting a /goal prompt, planning an overnight autonomous coding run, converting rambling specifications into a self-contained agentic mission, or setting up multi-agent autonomous loops — ev

• grill-me

  Interview the user relentlessly to sharpen an idea, requirement, or decision before execution. Use when a plan, design, requirement, or decision needs a focused interview to expose ambiguity, missing constraints, trade-offs, or weak assumptions — even if the user just says \"grill me on this\". Do N

• grill-with-docs

  Interview the user to stress-test a design while simultaneously recording domain terms and architectural decisions in project documentation. Use when planning features in a codebase and wanting domain terms captured in CONTEXT.md and ADRs — even if the user says \"grill this feature\". Do NOT use wh

• grilling

  Relentlessly interview the user round-by-round to stress-test thinking and expose unexamined assumptions. Use when the user requests a grilling interview, wants their idea challenged, or uses trigger phrases like \"grill me\" — even if they just say \"poke holes in my plan\". Do NOT use when the use

• handle-host-boundaries

  Handles unavailable named capabilities and destructive filesystem roots. Use when a required tool, command, picker, dialog, gate, or form may be unavailable; apply before acting even if the prompt asks to assume consent.

• handoff

  Compact current conversation context, decisions, evidence, and next actions into a portable markdown handoff for a fresh agent session. Use when ending a session, transferring work to another agent, switching workspaces, or preparing a resume point — even if the user just says \"save progress\". Do

• implement-spec

  Execute a full specification across task tickets using isolated subagent branches into a unified PR. Use when a specification with associated task-graph tickets is ready to implement across multiple subagents or isolated worktrees, and the goal is a complete pull request on a single branch — even if

• implement

  Build scoped code changes and run verification from an approved specification or plan. Use when a concrete spec, approved plan, or set of tickets is ready to implement, when the user asks to build or code a planned feature, or when executing tasks — even if they don't explicitly say \"implement\". D

• import-gpt

  Use when converting user-supplied GPT instructions or an authorized export into a local plugin candidate.

• import-plugins

  Use when adapting a selected folder of local skills or plugins into independent candidate packages.

• improve-codebase-architecture

  Survey codebases for shallow modules, weak seams, and deepening opportunities, producing a visual report. Use when conducting architectural reviews, identifying design debt, finding deepening opportunities, or preparing codebase refactors — even if the user says \"analyze our architecture\". Do NOT

• improve-skill

  Use when the user wants to improve an existing Codex skill from evaluation evidence while preserving intent, invocation policy, provenance and rollback.

• install-skill

  Use when the user wants to inventory, preview or install a Codex skill from a local directory or GitHub URL with validation, hashes, receipts and no overwrite.

• j-space

  Operate the agent's inner cognitive workspace for multi-step reasoning, long-horizon planning, deep debugging, and calibrated self-monitoring. Use when tackling complex multi-step problems, architecture design, long mechanical tasks requiring goal preservation, suspicious input audits, or when asked

• listing-writer

  Use when a validated ChatGPT/Codex Plugin needs accurate Plugin Directory fields, discovery metadata, starter prompts, and reviewer-facing listing details grounded in the packaged product.

• local-management

  Use when inspecting local plugin identities, dependencies, declarations and installation evidence.

• metric-pack

  Use when adding task-specific verifiers and metrics to a plugin or skill evaluation.

• migrate-to-shoehorn

  Migrate unsafe TypeScript test assertions to @total-typescript/shoehorn with explicit fixture intent. Use when test files contain unsafe `as` or `as unknown as` typecasts, when mock fixtures break under typechecking, or when modernizing test typing — even if the user says \"fix test type assertions\

• ml-best-practices

  Statistical machine learning best practices, exploratory data analysis, feature engineering, and rigorous model evaluation. Use when analyzing tabular datasets, engineering features, training classifiers or regressors, forecasting time series, or computing 95% bootstrap confidence intervals — even i

• modern-web

  Use when building or reviewing Studio HTML reports, responsive tables, accessibility, CSS or client-side browser behavior.

• plugin-autopilot

  Use when converting an agentic repository into a ChatGPT/Codex Plugin or when building, repairing, validating, packaging, submitting, publishing, or auditing an existing Plugin.

• plugin-eval

  Use when assessing a plugin package, its skills, runtime declarations, budget or release readiness.

• plugin-skill-studio

  Use when building, discovering, reviewing, importing or managing plugins and skills with the self-contained Studio.

• portfolio

  Use when the user wants to inspect a directory of plugins and skills, maintain the complete worklist, distinguish duplicates from references, or choose the next candidate.

• prototype

  Build a throwaway prototype to answer a specific design, state model, or UI exploration question. Use when evaluating whether an interface feels right, exploring UI concepts, or testing logic before committing to a full spec — even if the user says \"mock this up\". Do NOT use for production impleme

• python-executor

  Use when a ChatGPT/Codex Plugin workflow needs deterministic computation, file processing, repository checks, package inspection, or other work that should be actually executed with host-native Python instead of answered from unverified reasoning.

• receiving-code-review

  Verifies code review feedback before implementation and pushes back with evidence when a claim is wrong. Use when feedback is unclear, risky, or technically questionable.

• refactor-safely

  Refactors working or legacy code without changing observable behavior, using characterization tests when needed. Use when code is messy, nested, duplicated, or uncovered.

• release-workflow

  Use when preparing, packaging or resuming a plugin release with evidence and bounded retries.

• repo-discovery

  Use when an existing repository contains agents, prompts, workflows, playbooks, commands, or Skills and you need to identify which capabilities are worth converting into a ChatGPT/Codex Plugin.

• requesting-code-review

  Dispatches a bounded reviewer and preserves verified findings. Use when completed work needs read-only review before merge.

• research-systematically

  Runs source-bound research and version-matched documentation lookup. Use when comparisons, experiments, benchmarks, investigations, or external library, SDK, CLI, and API facts must be verified.

• research

  Investigate a technical question against high-trust primary sources and capture findings as a cited Markdown note. Use when gathering API facts, reading documentation, verifying library capabilities, or delegating reading legwork — even if the user says \"look into this library\". Do NOT use for wri

• resolving-merge-conflicts

  Resolve in-progress git merge or rebase conflicts by intent traced to primary sources. Use when hit with merge conflicts, CONFLICT markers in files, rebase pauses, or when git prompts to resolve conflicted hunks — even if the user just says \"fix this merge\". Do NOT use for creating new branches or

• retro

  Conduct a retrospective on a coding session to systematically improve agent environment, navigation pointers, automated checks, coding standards, tool economy, or AGENTS.md instructions. Use when reflecting on completed work, auditing agent mistakes, or optimizing repository rules — even if the user

• review-decision

  Use when deciding which parts of a reviewed skill or plugin require human attention.

• risk-review

  Use when reviewing skills or plugins for risky instructions, downloads, permissions or secret exposure before admitting them.

• scaffold-exercises

  Scaffold course, workshop, or tutorial exercises following repository conventions. Use when creating exercise folders, problem/solution/explainer variants, numbered lesson files, or workshop boilerplate — even if the user says \"add a new exercise\". Do NOT use for routine application feature scaffo

• setup-engineering-workflows

  Configure repository issue-tracking, triage-label, domain-doc, and agent-instruction conventions. Use when initializing engineering workflows in a repo, configuring GitHub/GitLab issue labels, or establishing CONTEXT.md conventions — even if the user says \"setup our workflows\". Do NOT use for gene

• setup-pre-commit

  Configure pre-commit quality checks with Husky and lint-staged while preserving package manager conventions. Use when setting up git pre-commit hooks, automated formatters, staged linters, or typecheck gates — even if the user says \"add pre-commit hooks\". Do NOT use for continuous integration (CI)

• setup-ts-deep-modules

  Enforce TypeScript package boundaries, entry points, and cyclic dependency rules with dependency-cruiser. Use when structuring monorepo packages, establishing public API entry points, or preventing circular imports — even if the user says \"fix TS package boundaries\". Do NOT use for non-TypeScript

• skill-conductor

  Author, refine, evaluate, and package agent skills across their full lifecycle. Use when building a new skill from scratch, improving an existing skill, fixing a skill that triggers unreliably, running skill evals, benchmarking skill performance, or packaging skills for distribution — even if they d

• skill-eval

  Use when evaluating an agent skill, testing its triggers or behavior, comparing revisions, or explaining its budget.

• skill-review

  Use when a skill needs a behavior-focused technical review beyond structural validation.

• skill-walkthrough

  Use when explaining what a skill does, what it can touch, and how to review it.

• skillquiver-doctor

  Audits the current ChatGPT, Claude Code, or Codex host for conflicting skills, plugins, and persistent hooks, then offers reversible per-item repairs. Use when skills duplicate, shadow, double-fire, load at the wrong time, or when the user asks to doctor or clean up Skillquiver conflicts.

• solve-efficiently

  Routes multi-module work with progressive discovery, matched effort, and context economy. Use when boundaries are unclear, context must stay small, or a durable project map is needed.

• subagent-driven-development

  Executes an implementation plan by dispatching one subagent per task with per-task review gates, keeping the orchestrator's context small. Use when executing plans with independent tasks in the current session.

• submission-builder

  Use when an exact ChatGPT/Codex Plugin artifact has passed local package, brand, and listing gates and you need reviewer-ready submission evidence without confusing preparation, submission, approval, and publication states.

• tdd

  Implement features and bug fixes test-first using red-green-refactor cycles. Use when writing new functionality, adding regression tests, fixing bugs with test coverage, or designing behavior through test assertions — even if the user says \"write tests for this\". Do NOT use for throwaway explorato

• teach

  Teach a technical concept interactively using the workspace as an active learning lab with durable learning records. Use when the user asks to understand a codebase concept, learn a language feature, explore design patterns, or practice coding skills — even if they say \"explain how this works to me

• test-driven-development

  Runs a recorded red-green-refactor cycle. Use when implementing a feature, bug fix, or behavior change.

• to-questionnaire

  Transform unknown requirements and stakeholder dependencies into a structured questionnaire. Use when a plan or spec is blocked by external stakeholder decisions, business rules, or missing domain facts — even if the user says \"what should I ask them?\". Do NOT use when the user can answer the ques

• to-spec

  Synthesize conversation and codebase context into an unambiguous, buildable technical specification. Use when requirements and design decisions are settled and need to be formalized into a technical spec — even if the user says \"write a spec for this\". Do NOT use when the core idea is still fuzzy

• to-tickets

  Decompose an approved specification or plan into ordered, dependency-linked tracer-bullet implementation tickets. Use when turning a spec or architectural plan into actionable tracker issues with clear acceptance criteria — even if the user says \"break this into tickets\". Do NOT use for initial re

• triage

  Classify, verify, and prepare external bug reports and feature requests into agent-ready briefs. Use when processing incoming issues, validating bug reproductions, rejecting out-of-scope requests, or structuring contributor tickets — even if the user says \"triage these issues\". Do NOT use for inte

• update-plugin
• using-git-worktrees
• verification-before-completion
• verify-work
• wait-what
• wayfinder
• wizard
• workflow-compiler
• workflow-designer
• workspace-operator
• writing-beats
• writing-for-agents
• writing-fragments
• writing-plans
• writing-shape

Similar plugins