DmitryPogrebnoy avatar

ruby-type-signature-skills

Skills for writing, maintaining and migrating Ruby type signatures (RBS, Sorbet, and others)

GitHub stars
28

Install

/plugin install ruby-type-signature-skills@ruby-agent-skills

Run it inside Claude Code after adding the marketplace with /plugin marketplace add DmitryPogrebnoy/ruby-agent-skills.

Contents

Discovered from source

Skills 4

RBS-Inline Generation Skill

Generate or update RBS-inline type annotations as comments directly in Ruby source files. Supports both full generation from scratch and partial updates for individual changed files. Unlike pure RBS which uses separate .rbs files, rbs-inline embeds type information as structured comments within Ruby code.

Instructions

When generating RBS-inline annotations, always follow these steps.

Copy this checklist and track your progress:

RBS-Inline Generation Progress:
- [ ] Step 1: Analyze the Ruby source
- [ ] Step 2: Add RBS-inline annotations
- [ ] Step 3: Eliminate `untyped` types in annotations
- [ ] Step 4: Review and refine annotations
- [ ] Step 5: Validate annotations
- [ ] Step 6: Ensure type safety (only if steep is configured)

Rules

  • You MUST NOT run Ruby code of the project.
  • You MUST NOT use untyped. Infer the proper type instead.
  • You MUST ask the user to provide more details if something is not clear.
  • You MUST prepend any command with bundle exec if the project has Gemfile.
  • You MUST use # @rbs comment syntax for inline annotations.
  • You MUST NOT use regular RBS signatures and .rbs files in the project.
  • You MUST use the tracking file when processing multiple files to ensure no files are missed.

Multi-File Processing

When processing multiple Ruby files, create a tracking file to ensure all files are covered:

  1. Create tracking file .rbs-inline-generation-todo.tmp:

    [ ] app/models/user.rb
    [ ] app/models/post.rb
    [ ] app/services/auth_service.rb
    
  2. Process files one by one:

    • Take the next pending [ ] entry
    • Complete all steps (1-6) for that file
    • Mark as processed [x]
    • Save the tracking file
    • Continue to next pending entry
  3. Cleanup: Remove the tracking file after all files are processed:

    rm .rbs-inline-generation-todo.tmp
    

If interrupted, the tracking file allows resuming from where you left off.

1. Analyze the Ruby Source

Always perform this step.

Read and understand the Ruby source file:

  • Identify all classes, modules, methods, constants and instance variables.
  • Note inheritance, module inclusion and definitions based on metaprogramming.
  • Note visibility modifiers - public, private, protected.
  • Note type parameters for generic classes.

2. Add RBS-Inline Annotations

Always perform this step.

  1. First, add the magic comment at the top of the Ruby file to enable rbs-inline processing:

    # rbs_inline: enabled
    
  2. Then add type annotations as comments directly in the Ruby source file using rbs-inline syntax:

Example - Before:

class User
  attr_reader :name, :age

  def initialize(name, age)
    @name = name
    @age = age
  end

  def greet(greeting)
    "#{greeting}, #{@name}!"
  end
end

Example - After:

# rbs_inline: enabled

class User
  attr_reader :name #: String
  attr_reader :age #: Integer

  # @rbs name: String
  # @rbs age: Integer
  # @rbs return: void
  def initialize(name, age)
    @name = name
    @age = age
  end

  #: (String) -> String
  def greet(greeting)
    "#{greeting}, #{@name}!"
  end
end
  • Follow RBS-inline syntax conventions strictly
    • See syntax.md for the full RBS-inline syntax guide
  • Pay extra attention to Data and Struct types

3. Eliminate untyped Types in Annotations

Always perform this step.

  • Review all annotations and replace untyped with proper types.
  • Use code context, method calls, and tests to infer types.
  • Use untyped only as a last resort when type cannot be determined.

4. Review and Refine Annotations

Always perform this step.

  • Verify annotations are correct, coherent, and complete.
  • Remove unnecessary untyped types.
  • Fix any errors and repeat until annotations are correct.

5. Validate Annotations

Always perform this step.

rbs-inline is a transpiler - it generates RBS files from inline annotations. Validation happens on the generated RBS output.

  1. Generate RBS files from annotations:

    rbs-inline --output lib
    

    This generates .rbs files in sig/generated/ directory.

  2. Validate the generated RBS files:

    rbs validate
    

    This checks syntax, name resolution, inheritance, and type applications.

  3. Fix any errors in your inline annotations and repeat until validation passes.

6. Ensure Type Safety

Perform this step ONLY if the project Gemfile includes steep gem AND the project has Steepfile.

Steep works on RBS files, not directly on inline annotations. The RBS files must be generated first (step 5).

  1. Ensure RBS files are generated from annotations:

    rbs-inline --output lib
    
  2. Run Steep type checker:

    steep check
    
  3. Fix any errors reported by steep check.

    • Do not modify Steepfile to fix errors.
    • Fix the inline annotations in Ruby source files.
    • Regenerate RBS files and repeat until no errors.

References

RBS Generate Skill

Generate or update pure RBS signatures for Ruby source files. Supports both full generation from scratch and partial updates for individual changed files. Does not handle RBS-inline signatures.

Instructions

When generating RBS signatures from scratch, always follow these steps.

Copy this checklist and track your progress:

RBS Generation Progress:
- [ ] Step 1: Analyze the Ruby source
- [ ] Step 2: Generate RBS signatures
- [ ] Step 3: Eliminate `untyped` types in generated signatures
- [ ] Step 4: Review and refine RBS signatures
- [ ] Step 5: Validate shape of RBS signatures
- [ ] Step 6: Ensure type safety (only if steep is configured)

Rules

There are several rules that you MUST follow while performing this skill:

  • You MUST not run Ruby code of the project.
  • You MUST not use untyped. Infer the proper type instead.
  • You MUST ask the user to provide more details if something is not clear.
  • You MUST prepend any command with bundle exec if the project has Gemfile.
  • You MUST use the tracking file when processing multiple files to ensure no files are missed.

Multi-File Processing

When processing multiple Ruby files, create a tracking file to ensure all files are covered:

  1. Create tracking file .rbs-generation-todo.tmp:

    [ ] app/models/user.rb
    [ ] app/models/post.rb
    [ ] app/services/auth_service.rb
    
  2. Process files one by one:

    • Take the next pending [ ] entry
    • Complete all steps (1-6) for that file
    • Mark as processed [x]
    • Save the tracking file
    • Continue to next pending entry
  3. Cleanup: Remove the tracking file after all files are processed:

    rm .rbs-generation-todo.tmp
    

If interrupted, the tracking file allows resuming from where you left off.

1. Analyze the Ruby Source

Always perform this step.

Read and understand the Ruby source file:

  • Identify all classes, modules, methods, constants and instance variables.
  • Note inheritance, module inclusion and definitions based on metaprogramming.
  • Note visibility modifiers - public, private, protected.
  • Note type parameters for generic classes.

2. Generate RBS Signatures

Always perform this step.

  • Create necessary .rbs files for the target Ruby file.
  • Place generated RBS files in sig/ directory mirroring Ruby source structure.
  • You need to strongly follow RBS syntax conventions to describe types for all declarations
    • See syntax.md for the full list of RBS types. Double-check it in tricky cases.
  • Take inspiration from RBS signature examples
    • See rbs_by_example.md for short list of RBS signatures examples
    • See core for RBS signatures of Ruby core library
    • See stdlib for RBS signatures of Ruby standard library
    • Pay extra attention to Data and Struct types. See data_and_struct.md for handling guide
    • See gem_rbs_collection for RBS signature examples of different Ruby libraries. This link contains only RBS files, Ruby sources are not included.

3. Eliminate untyped types in generated signatures

Always perform this step.

  • Go through all generated signatures and replace untyped with the proper type.
  • Use assumptions and calls examples in Ruby code and tests to infer the proper type.
  • If you cannot infer the proper type, leave it as untyped.
    • It is a last resort, use it only when there is no other option.

4. Review and refine RBS signatures

Always perform this step.

  • Take a look at the generated signatures and make sure they are correct, coherent and complete.
  • Try to get rid of any unnecessary untyped types.
  • If you find any errors, please fix them and repeat the process until there are no errors.

5. Validate shape of RBS signatures

Always perform this step.

  • Run rbs validate to verify that existing and new .rbs files are internally consistent. It will check syntax, name resolution, inheritance, method overloading, type variables, etc.
  • Fix any errors reported by rbs validate and repeat the process until there are no errors.

6. Ensure type safety of RBS signatures

Perform this step ONLY if the project Gemfile includes steep gem AND the project has Steepfile.

  • Run steep check to verify that generated RBS signatures are type safe.
  • Fix any errors reported by steep check and repeat the process until there are no errors.
    • Do not modify Steepfile in an attempt to fix errors.
  • Roll back to step 4 if you fixed any errors reported by steep check.

References

Sorbet Inline Generation Skill

Generate or update Sorbet type signatures using sig {} blocks directly in Ruby source files. Supports both full generation from scratch and partial updates for individual changed files. Sorbet signatures are valid Ruby code that enable both static and runtime type checking.

Instructions

When generating Sorbet inline signatures, always follow these steps.

Copy this checklist and track your progress:

Sorbet Inline Generation Progress:
- [ ] Step 1: Analyze the Ruby source
- [ ] Step 2: Add Sorbet signatures
- [ ] Step 3: Eliminate `T.untyped` in signatures
- [ ] Step 4: Review and refine signatures
- [ ] Step 5: Validate signatures with Sorbet

Rules

  • You MUST NOT run Ruby code of the project.
  • You MUST NOT use T.untyped. Infer the proper type instead.
  • You MUST NOT use T.unsafe - it bypasses type checking entirely.
  • You MUST NOT use T.cast - it forces types without verification.
  • You MUST ask the user to provide more details if something is not clear.
  • You MUST prepend any command with bundle exec if the project has Gemfile.
  • You MUST use sig { } block syntax for method signatures.
  • You MUST add extend T::Sig to classes/modules before using sig.
  • You MUST focus on method signatures only. Skip local variables, intermediate expressions, and other non-method annotations.
  • You MUST NOT use or generate .rbi files. This skill is for inline signatures only.
  • You MUST preserve the existing # typed: sigil level if one exists. Do not upgrade or change strictness without explicit user consent.
  • You MUST use the tracking file when processing multiple files to ensure no files are missed.

Multi-File Processing

When processing multiple Ruby files, create a tracking file to ensure all files are covered:

  1. Create tracking file .sorbet-inline-generation-todo.tmp:

    [ ] app/models/user.rb
    [ ] app/models/post.rb
    [ ] app/services/auth_service.rb
    
  2. Process files one by one:

    • Take the next pending [ ] entry
    • Complete all steps (1-5) for that file
    • Mark as processed [x]
    • Save the tracking file
    • Continue to next pending entry
  3. Cleanup: Remove the tracking file after all files are processed:

    rm .sorbet-inline-generation-todo.tmp
    

If interrupted, the tracking file allows resuming from where you left off.

1. Analyze the Ruby Source

Always perform this step.

Read and understand the Ruby source file:

  • Identify all classes, modules, methods, constants and instance variables.
  • Note inheritance, module inclusion and definitions based on metaprogramming.
  • Note visibility modifiers - public, private, protected.
  • Note existing # typed: sigil level at the top of the file.
  • Note type parameters for generic classes.

2. Add Sorbet Signatures

Always perform this step.

  1. First, check if the file already has a # typed: sigil at the top:

    • If sigil exists: Preserve the existing level. Do not change it without user consent.
    • If no sigil exists: Add # typed: true as a sensible default (allows gradual typing).

    Sigil levels (least to most strict): ignore < false < true < strict < strong

  2. Add extend T::Sig to the class/module:

    class MyClass
      extend T::Sig
    end
    
  3. Then add type signatures using sig {} blocks:

Example - Before:

class User
  attr_reader :name, :age

  def initialize(name, age)
    @name = name
    @age = age
  end

  def greet(greeting)
    "#{greeting}, #{@name}!"
  end
end

Example - After:

# typed: true

class User
  extend T::Sig

  sig { returns(String) }
  attr_reader :name

  sig { returns(Integer) }
  attr_reader :age

  sig { params(name: String, age: Integer).void }
  def initialize(name, age)
    @name = name
    @age = age
  end

  sig { params(greeting: String).returns(String) }
  def greet(greeting)
    "#{greeting}, #{@name}!"
  end
end
  • Focus on method and attribute signatures only
  • See syntax.md for the full Sorbet syntax guide

3. Eliminate T.untyped in Signatures

Always perform this step.

  • Review all signatures and replace T.untyped with proper types.
  • Use code context, method calls, and tests to infer types.
  • Use T.untyped only as a last resort when type cannot be determined.

4. Review and Refine Signatures

Always perform this step.

  • Verify signatures are correct, coherent, and complete.
  • Remove unnecessary T.untyped types.
  • Ensure all methods and attributes have signatures.
  • Fix any errors and repeat until signatures are correct.

5. Validate Signatures with Sorbet

Always perform this step.

Run Sorbet type checker to validate signatures:

srb tc

Or with bundle:

bundle exec srb tc

This checks:

  • Signature syntax correctness
  • Type consistency
  • Method parameter/return type matching
  • Instance variable initialization

Fix any errors reported and repeat until validation passes.

References

Sorbet RBI Generation Skill

Generate or update Sorbet type signatures in separate .rbi files. Supports both full generation from scratch and partial updates for individual changed files. RBI files are used when you cannot or should not modify the original Ruby source - such as for gems, generated code, or legacy codebases.

Instructions

When generating Sorbet RBI signatures, always follow these steps.

Copy this checklist and track your progress:

Sorbet RBI Generation Progress:
- [ ] Step 1: Analyze the Ruby source
- [ ] Step 2: Generate RBI files
- [ ] Step 3: Eliminate `T.untyped` in signatures
- [ ] Step 4: Review and refine signatures
- [ ] Step 5: Validate signatures with Sorbet

Rules

  • You MUST NOT run Ruby code of the project.
  • You MUST NOT use T.untyped. Infer the proper type instead.
  • You MUST NOT use T.unsafe - it bypasses type checking entirely.
  • You MUST NOT use T.cast - it forces types without verification.
  • You MUST ask the user to provide more details if something is not clear.
  • You MUST prepend any command with bundle exec if the project has Gemfile.
  • You MUST use sig { } block syntax for method signatures.
  • You MUST add extend T::Sig to classes/modules before using sig.
  • You MUST NOT add method bodies in RBI files - only signatures and empty method definitions.
  • You MUST place RBI files in ./rbi directory.
  • You MUST use the tracking file when processing multiple files to ensure no files are missed.

Multi-File Processing

When processing multiple Ruby files, create a tracking file to ensure all files are covered:

  1. Create tracking file .sorbet-rbi-generation-todo.tmp:

    [ ] app/models/user.rb
    [ ] app/models/post.rb
    [ ] app/services/auth_service.rb
    
  2. Process files one by one:

    • Take the next pending [ ] entry
    • Complete all steps (1-5) for that file
    • Mark as processed [x]
    • Save the tracking file
    • Continue to next pending entry
  3. Cleanup: Remove the tracking file after all files are processed:

    rm .sorbet-rbi-generation-todo.tmp
    

If interrupted, the tracking file allows resuming from where you left off.

1. Analyze the Ruby Source

Always perform this step.

Read and understand the Ruby source file:

  • Identify all classes, modules, methods, constants and instance variables.
  • Note inheritance, module inclusion and definitions based on metaprogramming.
  • Note visibility modifiers - public, private, protected.
  • Note type parameters for generic classes.

2. Generate RBI Files

Always perform this step.

  1. Determine the correct RBI directory:

    Place RBI files in ./rbi directory. Sorbet reads all .rbi files from this location.

    RBI files are needed to describe code Sorbet cannot understand statically:

    • Gem definitions
    • Methods created with define_method or method_missing
    • Constants from const_get/const_set
    • Dynamic ancestors added via extend
    • DSL-generated methods (Rails, ActiveRecord, etc.)
  2. Create the RBI file with typed sigil:

    # typed: strict
    
  3. Add extend T::Sig to each class/module:

    class MyClass
      extend T::Sig
    end
    
  4. Add method stubs with signatures (no method bodies):

Example - Ruby Source:

class User
  attr_reader :name, :age

  def initialize(name, age)
    @name = name
    @age = age
  end

  def greet(greeting)
    "#{greeting}, #{@name}!"
  end
end

Example - RBI File (rbi/user.rbi):

# typed: strict

class User
  extend T::Sig

  sig { returns(String) }
  attr_reader :name

  sig { returns(Integer) }
  attr_reader :age

  sig { params(name: String, age: Integer).void }
  def initialize(name, age); end

  sig { params(greeting: String).returns(String) }
  def greet(greeting); end
end
  • RBI files mirror structure but contain only signatures and empty method stubs
  • See syntax.md for the full Sorbet RBI syntax guide

3. Eliminate T.untyped in Signatures

Always perform this step.

  • Review all signatures and replace T.untyped with proper types.
  • Use code context, method calls, and tests to infer types.
  • Use T.untyped only as a last resort when type cannot be determined.

4. Review and Refine Signatures

Always perform this step.

  • Verify signatures are correct, coherent, and complete.
  • Remove unnecessary T.untyped types.
  • Ensure all methods and attributes have signatures.
  • Verify class hierarchy and module inclusions match the source.
  • Fix any errors and repeat until signatures are correct.

5. Validate Signatures with Sorbet

Always perform this step.

Run Sorbet type checker to validate signatures:

srb tc

Or with bundle:

bundle exec srb tc

This checks:

  • Signature syntax correctness
  • Type consistency
  • Method parameter/return type matching
  • Class/module structure matching source

Fix any errors reported and repeat until validation passes.

References

Agents 1

Update Signatures Agent

Updates or generates Ruby type signatures (RBS or Sorbet) for uncommitted file changes in a Git repository.

Instructions

When updating type signatures for uncommitted changes, always follow these steps.

Copy this checklist and track your progress:

Update Signatures Progress:
- [ ] Step 1: Get changed Ruby files from Git and create tracking file
- [ ] Step 2: Detect signature system (RBS vs Sorbet)
- [ ] Step 3: Detect signature style (inline vs separate)
- [ ] Step 4: Process each file using appropriate skill (mark progress in tracking file)
- [ ] Step 5: Report results and cleanup tracking file

Rules

There are several rules that you MUST follow while performing this agent:

  • You MUST verify this is a Git repository before proceeding.
  • You MUST auto-detect the signature system unless the user provides override.
  • You MUST auto-detect the signature style unless the user provides override.
  • You MUST use the existing skills for actual signature generation – do not duplicate their logic.
  • You MUST ask the user if detection is ambiguous (both systems detected or neither).
  • You MUST use the tracking file (.signatures-todo.tmp) to track progress and mark each file as processed.
  • You MUST remove the tracking file only after all files are successfully processed.

User Overrides

The user may provide flags to override auto-detection:

  • --rbs - Force RBS signature system
  • --sorbet - Force Sorbet signature system
  • --inline - Force inline signature style
  • --separate - Force separate file signature style

If overrides are provided, skip the corresponding detection step.

Step 1: Get Changed Ruby Files from Git

Always perform this step.

First, verify this is a Git repository:

git rev-parse --git-dir

If not a Git repository, inform the user and exit.

Get all uncommitted Ruby file changes (staged, unstaged, and untracked):

# Staged changes (including deleted files)
git diff --cached --name-only --diff-filter=ACMD -- '*.rb'

# Unstaged changes (including deleted files)
git diff --name-only --diff-filter=ACMD -- '*.rb'

# Untracked Ruby files (ask user if they want to include these)
git ls-files --others --exclude-standard -- '*.rb'

Combine results and remove duplicates.

If no Ruby files have changed, inform the user and exit.

Create Tracking File

Create a temporary tracking file .signatures-todo.tmp to track progress through all changed files:

# .signatures-todo.tmp format:
# All entries start as [ ] pending, mark [x] when processed
# (deleted) suffix indicates the Ruby file was deleted
# Example:
[ ] app/models/user.rb
[ ] app/services/auth_service.rb
[ ] app/models/old_model.rb (deleted)

For each changed file, add a pending entry:

  • [ ] path/to/file.rb - for existing files (to generate/update)
  • [ ] path/to/file.rb (deleted) - for deleted files (to remove signatures)

This file ensures no changes are missed and allows resuming if interrupted.

Process Files

Go through each pending [ ] entry in the tracking file one by one:

  1. Process the file:
    • If file exists: generate/update signatures using the appropriate skill
    • If file is marked (deleted): remove corresponding signature file (.rbs or .rbi)
  2. Mark as processed by changing [ ] to [x]
  3. Save the tracking file after each file is processed
  4. Move to the next pending entry

Step 2: Detect Signature System (RBS vs Sorbet)

Perform this step unless user provided --rbs or --sorbet override.

Use a scoring system to detect the signature system:

Sorbet indicators:

IndicatorScore
sorbet/ directory exists+3
.rbi files exist in project+2
sorbet or sorbet-runtime in Gemfile+3
tapioca in Gemfile+3
T::Sig or extend T::Sig in Ruby files+2

RBS indicators:

IndicatorScore
sig/ directory exists+3
.rbs files exist in project+2
rbs in Gemfile+2
steep in Gemfile+1
rbs-inline in Gemfile+2

Check indicators:

# Sorbet indicators
test -d sorbet && echo "sorbet_dir"
find . -name "*.rbi" -type f | head -1
grep -E "sorbet|sorbet-runtime|tapioca" Gemfile 2>/dev/null

# RBS indicators
test -d sig && echo "sig_dir"
find . -name "*.rbs" -type f | head -1
grep -E "^gem.*rbs|steep|rbs-inline" Gemfile 2>/dev/null

Calculate scores and determine system:

  • If Sorbet score > RBS score: Use Sorbet
  • If RBS score > Sorbet score: Use RBS
  • If scores are equal or both zero: Ask user which system to use

Step 3: Detect Signature Style (Inline vs Separate)

Perform this step unless user provided --inline or --separate override.

For Sorbet:

  • Inline indicators: sig { } blocks in .rb files, extend T::Sig usage
  • Separate indicators: .rbi files in rbi/ or sorbet/rbi/ directories
# Inline Sorbet
grep -r "sig {" --include="*.rb" . | wc -l
grep -r "extend T::Sig" --include="*.rb" . | wc -l

# Separate Sorbet
find . -path "*/rbi/*.rbi" -o -path "*/sorbet/rbi/*.rbi" | wc -l

For RBS:

  • Inline indicators: # @rbs comments or #: shorthand in .rb files, rbs_inline: enabled magic comment
  • Separate indicators: .rbs files in sig/ directory
# Inline RBS
grep -r "# @rbs\|#:" --include="*.rb" . | wc -l
grep -r "rbs_inline: enabled" --include="*.rb" . | wc -l

# Separate RBS
find sig -name "*.rbs" 2>/dev/null | wc -l

Compare counts:

  • If inline count > separate count: Use inline style
  • If separate count > inline count: Use separate style
  • If counts are equal or both zero: Ask user which style to prefer

Step 4: Invoke Appropriate Skill

Always perform this step.

Based on the detected (or user-specified) system and style, invoke the appropriate skill:

SystemStyleSkill to Invoke
RBSSeparategenerating-rbs
RBSInlinegenerating-rbs-inline
SorbetSeparategenerating-sorbet
SorbetInlinegenerating-sorbet-inline

For each pending [ ] entry in the tracking file (.signatures-todo.tmp):

  1. Read the next pending entry
  2. Process based on file status:
    • For existing files: Follow the instructions from the selected skill to generate/update signatures
    • For deleted files (marked with (deleted)): Remove the corresponding signature file
  3. Mark the entry as processed by changing [ ] to [x]
  4. Save the tracking file
  5. Continue to next pending entry

Important: Do not duplicate the signature generation logic. The skills contain all the necessary instructions for generating proper signatures.

Step 5: Report Results and Cleanup

Always perform this step.

Verify All Files Processed

Check the tracking file to ensure all entries are marked as [x]:

  • If any entries remain as [ ], process them before continuing
  • Do not proceed to cleanup until all files are processed

Remove Tracking File

Once all files are processed, remove the tracking file:

rm .signatures-todo.tmp

Provide Summary

Provide a summary to the user:

  • Number of Ruby files processed
  • Number of signature files removed (for deleted Ruby files)
  • Signature system used (RBS or Sorbet)
  • Signature style used (inline or separate)
  • List of files that were updated/created
  • List of signature files that were removed
  • Any files that were skipped and why
  • Any errors encountered

Example output:

Signature Update Complete:
- System: RBS
- Style: Separate (.rbs files)
- Files processed: 5
- Signatures removed: 1
- Signatures created/updated:
  - sig/models/user.rbs (created)
  - sig/models/post.rbs (updated)
  - sig/services/auth_service.rbs (created)
- Signatures removed:
  - sig/models/old_model.rbs (deleted)

Sponsors

Details

Marketplace
DmitryPogrebnoy/ruby-agent-skills
Source
plugins/ruby-type-signature-skills
Category
Community