reflection-method-find

Find C# methods across every loaded assembly by name / type / parameters — including private methods. Returns serialized `MethodData` entries usable as schemas for 'reflection-method-call'.

Quality

70%

Does it follow best practices?

Run evals on this skill

Adds up to 20 points to the overall score

View guide

Securityby

Passed

No findings from the security scan

Fix and improve this skill with Tessl

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

Quality

Content

63%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 is actionable and well-structured, with executable CLI examples, a complete input reference, and troubleshooting. Its weaknesses are duplicated match-level documentation, an inlined JSON schema that belongs in a reference file, and an unhelpful literal example value for the `filter` parameter.

Suggestions

Remove the duplicated match-level documentation — keep the enum details only in the Input table (or only in the 'Match levels' section) — and drop the redundant intro sentence restating the description.

Move the full input JSON schema to a `references/` file and keep a one-line pointer plus a minimal example inline, improving both conciseness and progressive disclosure.

Fix the example invocation to use a realistic `filter` object (namespace/typeName/methodName/inputParameters) and add a short end-to-end snippet showing a returned `MethodData` entry passed to `reflection-method-call`.

Dimension	Reasoning	Score
Conciseness	Mostly efficient, but the match-level semantics are documented twice — the 'Match levels' section and the `typeNameMatchLevel`/`methodNameMatchLevel`/`parametersMatchLevel` table rows repeat the same 0-6 enum — and the intro paragraph restates the frontmatter description. Not 2 because there is no padding that explains concepts Claude already knows.	3 / 5
Actionability	Provides fully executable `unity-mcp-cli run-tool` commands with `--input`, `--input-file`, and stdin variants, plus a troubleshooting section and a complete input table and JSON schema. Not 5 because the canonical example uses `"filter": "string_value"` while the schema requires `filter` to be a `MethodRef` object, so it is not copy-paste correct.	4 / 5
Workflow Clarity	The single-purpose find-then-call flow is clear: how to invoke, what the output looks like ('[Success] Found N method(s)' plus `MethodData` JSON), and how to recover from CLI-not-found errors. Not 5 because chaining a returned `MethodData` entry into 'reflection-method-call' as its `filter` is mentioned but never demonstrated, leaving the key next step implicit.	4 / 5
Progressive Disclosure	Sections are clearly labeled and navigable, but the ~70-line input JSON schema is inlined wholesale in a skill with no bundle files, which is content that belongs in a separate reference file. Fits the 'some structure but content that should be separate is inline' anchor; not 2 because nothing is buried and the structure is not minimal.	3 / 5
	Total	14 / 20 Passed

Description

62%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 distinctive, clearly stating what the skill does and what it returns, with a concrete link to its companion skill. Its main weaknesses are the absence of an explicit 'Use when...' trigger clause and missing natural trigger terms like 'reflection', 'invoke', or 'Unity'.

Suggestions

Add an explicit trigger clause, e.g. 'Use when you need to locate or invoke a C# method (including private ones) in a Unity project before calling it via reflection-method-call.'

Include natural trigger synonyms such as 'reflection', 'invoke', 'call method', and 'Unity' so users' phrasings match the description.

State when the results are useful (e.g. 'when you need a method's signature or want to invoke a private method') to strengthen the 'when' half.

Dimension	Reasoning	Score
Specificity	Lists several concrete actions — 'Find C# methods across every loaded assembly by name / type / parameters', 'including private methods', 'Returns serialized `MethodData` entries' — with only minor gaps in coverage (the find action and the returned artifact). Not 5 because it describes just two real actions rather than comprehensive coverage of what the skill offers.	4 / 5
Completeness	The 'what' is clear and specific, but there is no 'Use when...' clause — usage is only weakly implied through 'usable as schemas for reflection-method-call'. Per guidelines, a missing explicit trigger clause caps completeness at 3; it is not 2 because the 'what' is fully explicit.	3 / 5
Trigger Term Quality	Relevant keywords like 'C# methods', 'assembly', 'private methods' are present, but natural user phrases such as 'reflection', 'invoke/call a method', or 'Unity' are missing. Fits the 'some relevant keywords but missing common variations' anchor better than the 'good keyword coverage' anchor above.	3 / 5
Distinctiveness Conflict Risk	Occupies a clear niche (C# reflection method lookup) and is explicitly positioned as the find-counterpart to 'reflection-method-call', minimizing conflict risk with other skills. Not 4 because nothing in the description is generic enough to overlap with unrelated skills.	5 / 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-find/SKILL.md
Commit: 4c8056f

Reviewed: 8 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.