moonbit-evaluating-code

Analyzes uploaded chest images to identify and report probable pathological conditions, including TB, with high accuracy.

1|Updated Mar 7, 2026
One-click install
npx skills add https://github.com/c-tomioka/mbtorch --skill moonbit-evaluating-code
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: moonbit-evaluating-code
Source: https://github.com/c-tomioka/mbtorch/tree/main/.claude/skills/moonbit-evaluating-code
Command: npx skills add https://github.com/c-tomioka/mbtorch --skill moonbit-evaluating-code

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This skill identifies syntax issues, spec violations, and non-idiomatic MoonBit patterns in small modules and proposes concrete, compilable fixes that follow the official MoonBit language reference.

Core Features & Use Cases

  • Spec-based code review: Check MoonBit functions, types, methods, and package layouts against the bundled language resources and examples.
  • Concrete fixes: Return minimally invasive code edits or refactors that preserve behavior while aligning with idiomatic patterns.
  • Use cases: Inspect a single module before commit, fix small library APIs to match visibility/coherence rules, or convert anti-patterns into recommended examples.

Quick Start

Use the moonbit-evaluating-code skill to review a MoonBit file and return a short report of violations with suggested, compilable fixes.

Frequently Asked Questions about moonbit-evaluating-code

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

FAQPage Schema
How do I check my MoonBit code for spec violations and non-idiomatic patterns?

MoonBit code review involves evaluating modules, functions, and package layouts against the official language specification to identify syntax issues and non-idiomatic patterns. It produces annotated findings referencing language resources and proposes concrete, compilable fixes that preserve original behavior.

What is the best way to refactor MoonBit functions to align with the language spec?

Refactoring MoonBit functions requires applying minimally invasive code edits that align with idiomatic patterns while preserving behavior. This involves checking trait and method usage, visibility rules, and syntax against bundled language resources to ensure spec compliance.

Can I use this MoonBit code review to fix small library APIs before a commit?

Yes, you can inspect a single module before commit or fix small library APIs using MoonBit code review. It checks visibility and coherence rules, converting anti-patterns into recommended examples with compilable code changes.

Does static analysis for MoonBit cover trait and method usage checks?

Static analysis for MoonBit covers trait and method usage checks by evaluating code against the official language specification. It identifies spec violations in small modules and provides concrete fixes that follow idiomatic patterns and visibility rules.

When do I need MoonBit static analysis for package layouts?

You need MoonBit static analysis for package layouts when fixing small library APIs to match visibility and coherence rules. It evaluates package structures against the language reference to detect anti-patterns and propose compliant, idiomatic refactors.

Why does my MoonBit code contain non-idiomatic patterns after initial development?

MoonBit code often contains non-idiomatic patterns when syntax and visibility rules are not checked against the official language specification. Evaluating modules and functions against bundled resources identifies these anti-patterns and provides concrete, compilable fixes.