port-c-module

Guide for porting a C module to Rust. Use this when starting to port a C module to Rust.

Quality

45%

Does it follow best practices?

Impact

—

No eval scenarios have been run

Securityby

Passed

No known issues

Optimize this skill with Tessl

npx tessl skill review --optimize ./.skills/port-c-module/SKILL.md

Quality

Content

50%

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

This skill provides a reasonable multi-step workflow for porting C modules to Rust with clear sequencing and some concrete commands. Its main weaknesses are the lack of explicit validation checkpoints between steps (especially before destructive operations like deleting C headers), and the absence of concrete code examples for the FFI wrapper pattern. The analysis and planning steps are more descriptive than actionable.

Suggestions

Add explicit validation checkpoints between steps—e.g., 'Verify cargo test passes before proceeding to FFI wrapper' and 'Run build.sh RUN_UNIT_TESTS before deleting C header files in step 7'.

Include a concrete, copy-paste-ready FFI wrapper code example (e.g., a sample #[unsafe(no_mangle)] pub extern "C" fn with SAFETY comments) rather than just describing what the FFI crate should contain.

Provide a minimal template for the $ARGUMENTS_plan.md file so Claude knows the expected structure and content.

Trim the sub-bullets under 'Analyze the C Code' to only project-specific considerations Claude wouldn't already know (e.g., Redis module interactions, the specific directory layout).

Dimension	Reasoning	Score
Conciseness	Generally efficient but includes some unnecessary elaboration, such as the sub-bullets under 'Analyze the C Code' that explain considerations Claude would naturally understand (e.g., 'Understand data structures and their lifetimes'). The overall structure is reasonable but could be tightened.	2 / 3
Actionability	Provides concrete bash commands for crate creation and testing, and references specific directory structures. However, several steps (Analyze, Define Plan, Implement, Compare API) remain at the level of guidance rather than executable instructions—no concrete code examples for FFI wrappers, no template for the plan file, and the FFI section uses description rather than a concrete example.	2 / 3
Workflow Clarity	The 8-step sequence is clearly numbered and logically ordered, with a feedback loop at step 5 ('Go back to step 1 if...'). However, there are no explicit validation checkpoints between steps (e.g., verifying the Rust crate compiles before moving to FFI, or checking that tests pass before wiring up C code). For a destructive operation like deleting C header files in step 7, the lack of a pre-deletion validation checkpoint is a notable gap.	2 / 3
Progressive Disclosure	References an example module (src/redisearch_rs/trie_rs/) and suggests creating a plan file, which is good. However, all content is inline in a single file with no references to supporting documents, and the inline content is moderately long. The plan file template and FFI patterns could be split into referenced files for better organization.	2 / 3
	Total	8 / 12 Passed

Description

40%

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 too terse and vague, essentially restating the same idea twice (once as the 'what' and once as the 'when'). It identifies a reasonably specific domain (C-to-Rust porting) but fails to enumerate concrete actions or provide meaningful trigger term coverage beyond the most obvious keywords.

Suggestions

Add specific concrete actions the skill performs, e.g., 'Converts C data structures, memory management patterns, and build configurations to idiomatic Rust. Handles FFI boundaries, unsafe code wrapping, and error handling translation.'

Expand trigger terms to include natural variations users might say: 'rewrite C in Rust', 'migrate C code', 'C-to-Rust', 'convert C module', 'transpile', 'FFI bindings'.

Make the 'Use when' clause more informative and distinct from the 'what' clause, e.g., 'Use when the user asks to rewrite, migrate, or convert C code to Rust, or when working with C/Rust interop and FFI boundaries.'

Dimension	Reasoning	Score
Specificity	The description says 'Guide for porting a C module to Rust' which is vague — it doesn't list any concrete actions like 'translates data structures', 'converts memory management patterns', or 'rewrites FFI bindings'. It merely names the domain without specifying what the skill actually does.	1 / 3
Completeness	It has a 'Use this when...' clause ('when starting to port a C module to Rust'), so it technically addresses both what and when. However, the 'what' is extremely thin ('Guide for porting') and the 'when' essentially just restates the what, providing no additional trigger guidance beyond the obvious.	2 / 3
Trigger Term Quality	It includes some relevant keywords like 'porting', 'C module', and 'Rust', which a user might naturally say. However, it misses common variations such as 'rewrite', 'migrate', 'C-to-Rust', 'FFI', 'unsafe code', or 'transpile'.	2 / 3
Distinctiveness Conflict Risk	The C-to-Rust porting niche is fairly specific and unlikely to conflict with many other skills. However, it could overlap with general Rust coding skills, C coding skills, or broader migration/refactoring skills due to the lack of concrete distinguishing actions.	2 / 3
	Total	7 / 12 Passed

Validation

90%

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 — 10 / 11 Passed

Validation for skill structure

Criteria	Description	Result
frontmatter_unknown_keys	Unknown frontmatter key(s) found; consider removing or moving to metadata	Warning

	Total	10 / 11 Passed

Repository: RediSearch/RediSearch
Commit: edefb25

Reviewed: about 1 month 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.