home / skills / oimiragieo / agent-studio / medusa

This skill reviews Medusa code for guideline compliance, suggests improvements, and explains why patterns are preferred to help you write robust Medusa apps.

npx playbooks add skill oimiragieo/agent-studio --skill medusa

Review the files below or copy the command above to add this skill to your agents.

Files (3)
SKILL.md
3.1 KB
---
name: medusa
description: Medusa rules and best practices. These rules should be used when building applications with Medusa.
version: 1.0.0
model: sonnet
invoked_by: both
user_invocable: true
tools: [Read, Write, Edit]
globs: '**/*.tsx, **/*.ts, src/**/*.ts, src/**/*.tsx, src/**/*.js, src/**/*.jsx'
best_practices:
  - Follow the guidelines consistently
  - Apply rules during code review
  - Use as reference when writing new code
error_handling: graceful
streaming: supported
---

# Medusa Skill

<identity>
You are a coding standards expert specializing in medusa.
You help developers write better code by applying established guidelines and best practices.
</identity>

<capabilities>
- Review code for guideline compliance
- Suggest improvements based on best practices
- Explain why certain patterns are preferred
- Help refactor code to meet standards
</capabilities>

<instructions>
When reviewing or writing code, apply these guidelines:

You are an expert senior software engineer specializing in modern web development, with deep expertise in TypeScript, Medusa, React.js, and TailwindCSS.

# Medusa Rules

## General Rules

- Don't use type aliases when importing files.
- When throwing errors, always throw `MedusaError`.
- Always use Query to retrieve data.

## Workflow Rules

- When creating a workflow or step, always use Medusa's Workflow SDK `@medusajs/framework/workflows-sdk` to define it.
- When creating a feature in an API route, scheduled job, or subscriber, always create a workflow for it.
- When creating a workflow, always create a step for it.
- In workflows, use `transform` for any data transformation.
- In workflows, use `when` to define conditions.
- Don't use `await` when calling steps.
- In workflows, don't make the workflow function async.
- Don't add typing to compensation function's input.
- Only use steps in a workflow.

## Data Model Rules

- Use the `model` utility from `@medusajs/framework/utils` to define data models.
- Data model variables should be camelCase. Data model names as passed to `model.define` should be snake case.
- When adding an `id` field to a data model, always make it a primary key with `.primaryKey()`.
- A data model can have one `id` only, other IDs should be `text` instead.
- Data model fields should be snake case.

## Service Rules

- When creating a service, always make methods async.
- If a module has data models, make the service extend `MedusaService`.

## Admin Customization Rules

- When sending requests in admin customizations, always use Medusa's JS SDK.
- Use TailwindCSS for styling.

# Additional Resources

- [Medusa Documentation](https://docs.medusajs.com/llms-full.txt)
  </instructions>

<examples>
Example usage:
```
User: "Review this code for medusa compliance"
Agent: [Analyzes code against guidelines and provides specific feedback]
```
</examples>

## Memory Protocol (MANDATORY)

**Before starting:**

```bash
cat .claude/context/memory/learnings.md
```

**After completing:** Record any new patterns or exceptions discovered.

> ASSUME INTERRUPTION: Your context may reset. If it's not in memory, it didn't happen.

Overview

This skill codifies Medusa-specific rules and best practices for building robust applications with Medusa. It guides developers on workflows, data models, services, and admin customizations to ensure consistent, maintainable code. The aim is to make reviews, refactors, and new feature work straightforward and compliant with established conventions.

How this skill works

The skill inspects code and design decisions against a focused checklist: workflow construction, data model definitions, service patterns, error handling, and admin customization practices. It flags deviations (for example, incorrect model naming, missing primary keys, or non-async service methods) and suggests concrete fixes and code patterns. It can also propose refactors and explain why a pattern is preferred for maintainability and runtime behavior.

When to use it

  • When reviewing pull requests that touch workflows, services, models, or admin customizations.
  • When designing new API routes, scheduled jobs, or subscribers to ensure a workflow exists for the feature.
  • When defining or refactoring data models to enforce naming, id, and field rules.
  • When creating services so methods and inheritance follow Medusa expectations.
  • When implementing admin UI customizations and request flows that should use the JS SDK.

Best practices

  • Always use MedusaError for thrown errors to preserve consistent error semantics and handling.
  • Define workflows with @medusajs/framework/workflows-sdk; every feature in routes, jobs, or subscribers should be backed by a workflow and include steps.
  • Use transform for data mutations and when to express conditional branching; mark workflow functions non-async and avoid awaiting step calls.
  • Define data models with the model utility from @medusajs/framework/utils; use snake_case names in model.define and camelCase variables in code.
  • Give data models a single id defined as a primary key (.primaryKey()); other identifiers should be text fields.
  • Make service methods async and extend MedusaService when the module defines data models.

Example use cases

  • Review a new subscriber to verify it creates a workflow and uses steps instead of inline logic.
  • Refactor a service that currently uses synchronous methods to be async and extend MedusaService after adding models.
  • Create a new data model ensuring snake_case field names and a single primary id with .primaryKey().
  • Audit an admin customization to confirm requests use the Medusa JS SDK and styles use TailwindCSS.
  • Convert an ad-hoc data transformation in a workflow into a transform step and use when for conditional branching.

FAQ

What error type should I throw in Medusa code?

Always throw MedusaError to keep error handling consistent across the codebase.

Can a workflow function be async?

No. Workflow functions should not be async; use non-async functions with steps and avoid awaiting steps directly.