reflection-method-call

Call a C# method by reflection — including private methods. Requires a method schema obtained via 'reflection-method-find'. Supports static methods, instance methods (with optional target deserialization), and main-thread / off-thread execution.

Quality

69%

Does it follow best practices?

Run evals on this skill

Adds up to 20 points to the overall score

View guide

Securityby

Critical

Do not install without reviewing

Fix and improve this skill with Tessl

tessl review fix ./Unity-MCP-Plugin/.claude/skills/reflection-method-call/SKILL.md

Quality

Content

57%Weight 40%Scale 1-5

Reviews the quality of instructions and guidance provided to agents. Good implementation is clear, handles edge cases, and produces reliable results.

The body delivers concrete CLI usage and complete parameter documentation, making it usable as-is. It is held back by duplication (match levels, SerializedMember schema), placeholder-only examples that are not runnable, an implicit rather than explicit find-then-call workflow, and inlined JSON schemas that belong in separate reference files.

Suggestions

Move the full Input/Output JSON schemas into references/ (e.g. references/schema.md) and keep only a compact parameter table plus one realistic example in SKILL.md, removing the duplicated SerializedMember block.

Replace the all-placeholder example with at least one real invocation, e.g. a filter object like {"typeName":"PlayerController","methodName":"TakeDamage"} with actual inputParameters, so the command is copy-paste runnable.

Make the workflow explicit as numbered steps: 1) run 'reflection-method-find' to get the method schema, 2) construct filter/inputParameters from that schema, 3) call this tool, 4) inspect the returned result field — and deduplicate the match-level documentation into one section.

Dimension	Reasoning	Score
Conciseness	The prose sections are lean, but content is duplicated: match levels are explained both in "## Match levels" and again row-by-row in the Input table, and the entire com.IvanMurzak.ReflectorNet.Model.SerializedMember schema block appears verbatim in both the Input and Output JSON schemas (~120 combined lines of schema). This could be tightened to a single authoritative copy.	3 / 5
Actionability	Concrete, executable commands are provided (unity-mcp-cli run-tool with --input, --input-file, and stdin heredoc variants) plus a troubleshooting note for a missing CLI. Not 5 because the example is all placeholders ("string_value" for every field, including "filter" which should be a MethodRef object), so it is not copy-paste runnable for a real call.	4 / 5
Workflow Clarity	The find-then-call sequence is present but only implicit ("Use 'reflection-method-find' to find available method before using it") — it is never laid out as ordered steps. There are no validation checkpoints, such as confirming the method schema was found before calling or interpreting a failed match, though the operation is a single non-destructive call.	3 / 5
Progressive Disclosure	The body has real section structure (Match levels, Inputs, How to Call, Input, Output) aiding navigation, but there are no bundle files at all and ~120 lines of JSON schema are inlined in SKILL.md — reference material that clearly belongs in a separate references/ file per the rubric's rationale.	3 / 5
	Total	13 / 20 Passed

Description

66%Weight 40%Scale 1-5

Based on the skill's description, can an agent find and select it at the right time? Clear, specific descriptions lead to better discovery.

The description is specific and domain-distinct, accurately summarizing the tool's capabilities in concrete terms. Its main weakness is the complete absence of a 'when to use this' trigger clause, which caps completeness and weakens discoverability relative to the rubric's strong examples.

Suggestions

Add an explicit trigger clause, e.g. "Use when you need to invoke a C# method at runtime — including private, static, or instance methods — such as calling Unity game code or testing internal APIs without modifying source."

Include a few missing natural trigger terms such as "invoke", ".NET", and "Unity" since the tool clearly targets Unity projects.

Briefly state the input/output contract (accepts typed parameters, returns the serialized method result) to round out capability coverage.

Dimension	Reasoning	Score
Specificity	"Call a C# method by reflection — including private methods" plus "Supports static methods, instance methods (with optional target deserialization), and main-thread / off-thread execution" lists several concrete capabilities. Not 5 because parameter passing and the returned result are never mentioned, leaving minor coverage gaps.	4 / 5
Completeness	The "what" is clearly stated (reflection-based C# method invocation with thread and target options), but there is no "Use when..." or equivalent explicit trigger guidance — only the prerequisite "Requires a method schema obtained via 'reflection-method-find'", which does not state when to invoke the skill. Per the rubric guideline, a missing trigger clause caps completeness at 3.	3 / 5
Trigger Term Quality	Natural terms a user would say are present: "C#", "method", "reflection", "private methods", "static", "instance". Not 5 because common synonyms and context words like "invoke", ".NET", and "Unity" are missing from the description.	4 / 5
Distinctiveness Conflict Risk	"Call a C# method by reflection — including private methods" carves a clear niche that is unlikely to trigger for unrelated skills. Not 5 because it overlaps with the sibling 'reflection-method-find' skill and related reflection tools, which the description itself references.	4 / 5
	Total	15 / 20 Passed

Validation

100%

Warnings & errors only

Checks the skill against the spec for correct structure and formatting. All validation checks must pass before discovery and implementation can be scored.

Validation — 16 / 16 Passed

Validation for skill structure

No warnings or errors.

Repository: IvanMurzak/Unity-MCP
Path: Unity-MCP-Plugin/.claude/skills/reflection-method-call/SKILL.md
Commit: 4c8056f

Reviewed: 9 days ago

Table of Contents

Discovery Implementation Validation

Is this your skill?

If you maintain this skill, you can claim it as your own. Once claimed, you can manage eval scenarios, bundle related skills, attach documentation or rules, and ensure cross-agent compatibility.