plugin-interaction-runtime-design

Designs plugin interaction, runtime contracts, and host adapters into a validated Plugin-Design.md.

Updated Jul 3, 2026
One-click install
npx skills add https://github.com/LYGOLANG/fufan-cc-flow --skill plugin-interaction-runtime-design-lygolang
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: plugin-interaction-runtime-design
Source: https://github.com/LYGOLANG/fufan-cc-flow/tree/main/bundled-plugins/plugin-builder/skills/plugin-interaction-runtime-design
Command: npx skills add https://github.com/LYGOLANG/fufan-cc-flow --skill plugin-interaction-runtime-design-lygolang

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve? It turns a finished plugin specification (Plugin-Spec.md and plugin.yaml) into a concrete interaction and runtime design, resolving how users and the host Agent collaborate, how MCP Tools and UI surfaces behave, and how the plugin runs on each required host target. ## Core Features & Use Cases - Structured Interview Loop: Separates user experience decisions from architect decisions and platform facts, asking only bounded, high-impact questions with a per-UI-class question budget. - Full Runtime Design: Produces UI-Agent request/result contracts, MCP Tool catalogs (render, app-only, agent-visible, long-running), state/file/job layers, host adapters with fallbacks, and a threat model. - Prototype Gate: Classifies UI complexity (A/B/C) and requires runnable spikes for high-risk editors before allowing DESIGN_READY status. - Use Case: After a plugin spec passes its requirements gate, run this Skill to interview the user on experience trade-offs, walk through seven failure and recovery scenarios, and output a validated Plugin-Design.md plus JSON schemas ready for development planning. ## Quick Start Ask the agent to run the plugin interaction and runtime design phase for the current plugin project so it interviews you and produces Plugin-Design.md.

Frequently Asked Questions about plugin-interaction-runtime-design

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I design the interaction and runtime layer for an MCP plugin?▼

Start from a validated Plugin-Spec.md and plugin.yaml, then classify decisions into user decisions, architect decisions, and platform facts. Interview the user only on experience trade-offs, define UI-Agent request and result contracts, MCP tool catalogs, state layers, and host adapters, then validate everything through scenario walkthroughs before writing Plugin-Design.md.

What is the difference between app-only and agent-visible MCP tools?▼

App-only tools are deterministic capabilities called only by the UI, such as load_state or upload_asset, and are hidden from the model. Agent-visible tools expose domain operations to the host agent, use domain-specific names, and include requestId, version checks, and structured outputs for safe write-backs.

When is a prototype spike required before plugin development?▼

A runnable spike is mandatory for UI Complexity Class C, which covers infinite canvases, timelines, 3D rendering, professional editor interactions, or large media handling. The spike validates the one to three highest-risk assumptions and must pass before the design can be marked DESIGN_READY.

How does the design handle different host targets like Claude Code?▼

Each target gets its own host adapter section with a primary path, UI surface, agent trigger, fallback, and verification method based on verified platform facts. If a required target has no feasible path, the design returns to the spec phase instead of assuming an ideal architecture.

What happens if the plugin spec has unresolved open questions?▼

If the spec contains P0 open questions, requirements without acceptance criteria, or an unclear required target, the design phase stops and returns to the spec-building skill. The design stage never guesses requirements on behalf of the specification.