
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-skillsRun it inside Claude Code after adding the marketplace with /plugin marketplace add DmitryPogrebnoy/ruby-agent-skills.
Contents
Discovered from sourceSkills 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 execif the project has Gemfile. - You MUST use
# @rbscomment syntax for inline annotations. - You MUST NOT use regular RBS signatures and
.rbsfiles 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:
-
Create tracking file
.rbs-inline-generation-todo.tmp:[ ] app/models/user.rb [ ] app/models/post.rb [ ] app/services/auth_service.rb -
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
- Take the next pending
-
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.
-
First, add the magic comment at the top of the Ruby file to enable rbs-inline processing:
# rbs_inline: enabled -
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
DataandStructtypes- See data-struct-support.md for Data and Struct handling
3. Eliminate untyped Types in Annotations
Always perform this step.
- Review all annotations and replace
untypedwith proper types. - Use code context, method calls, and tests to infer types.
- Use
untypedonly 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
untypedtypes. - 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.
-
Generate RBS files from annotations:
rbs-inline --output libThis generates
.rbsfiles insig/generated/directory. -
Validate the generated RBS files:
rbs validateThis checks syntax, name resolution, inheritance, and type applications.
-
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).
-
Ensure RBS files are generated from annotations:
rbs-inline --output lib -
Run Steep type checker:
steep check -
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
- syntax.md - RBS-inline syntax guide
- data-struct-support.md - Data and Struct handling in rbs-inline
- examples/ - Real-world rbs-inline examples from production gems
- rbs-inline repository - Official rbs-inline gem
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 execif 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:
-
Create tracking file
.rbs-generation-todo.tmp:[ ] app/models/user.rb [ ] app/models/post.rb [ ] app/services/auth_service.rb -
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
- Take the next pending
-
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
.rbsfiles 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
DataandStructtypes. 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
untypedwith 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
untypedtypes. - 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 validateto verify that existing and new.rbsfiles are internally consistent. It will check syntax, name resolution, inheritance, method overloading, type variables, etc. - Fix any errors reported by
rbs validateand 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 checkto verify that generated RBS signatures are type safe. - Fix any errors reported by
steep checkand 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
- syntax.md - The full list of RBS types and syntax
- rbs_by_example.md - Short list of RBS signatures examples
- core - RBS signatures of Ruby core library
- stdlib - RBS signatures of Ruby standard library
- data_and_struct.md - Explanation on
DataandStructtypes handling
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 execif the project has Gemfile. - You MUST use
sig { }block syntax for method signatures. - You MUST add
extend T::Sigto classes/modules before usingsig. - You MUST focus on method signatures only. Skip local variables, intermediate expressions, and other non-method annotations.
- You MUST NOT use or generate
.rbifiles. 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:
-
Create tracking file
.sorbet-inline-generation-todo.tmp:[ ] app/models/user.rb [ ] app/models/post.rb [ ] app/services/auth_service.rb -
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
- Take the next pending
-
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.
-
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: trueas a sensible default (allows gradual typing).
Sigil levels (least to most strict):
ignore<false<true<strict<strong -
Add
extend T::Sigto the class/module:class MyClass extend T::Sig end -
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.untypedwith proper types. - Use code context, method calls, and tests to infer types.
- Use
T.untypedonly 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.untypedtypes. - 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
- syntax.md - Sorbet signature syntax guide
- sorbet_examples/ - Real-world Sorbet examples from production gems
- Sorbet documentation - Official Sorbet docs
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 execif the project has Gemfile. - You MUST use
sig { }block syntax for method signatures. - You MUST add
extend T::Sigto classes/modules before usingsig. - You MUST NOT add method bodies in RBI files - only signatures and empty method definitions.
- You MUST place RBI files in
./rbidirectory. - 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:
-
Create tracking file
.sorbet-rbi-generation-todo.tmp:[ ] app/models/user.rb [ ] app/models/post.rb [ ] app/services/auth_service.rb -
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
- Take the next pending
-
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.
-
Determine the correct RBI directory:
Place RBI files in
./rbidirectory. Sorbet reads all.rbifiles from this location.RBI files are needed to describe code Sorbet cannot understand statically:
- Gem definitions
- Methods created with
define_methodormethod_missing - Constants from
const_get/const_set - Dynamic ancestors added via
extend - DSL-generated methods (Rails, ActiveRecord, etc.)
-
Create the RBI file with typed sigil:
# typed: strict -
Add
extend T::Sigto each class/module:class MyClass extend T::Sig end -
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.untypedwith proper types. - Use code context, method calls, and tests to infer types.
- Use
T.untypedonly 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.untypedtypes. - 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
- syntax.md - Sorbet RBI syntax guide
- references/ - Real-world RBI examples from stripe-ruby
- Sorbet RBI documentation - Official RBI docs
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:
- 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)
- Mark as processed by changing
[ ]to[x] - Save the tracking file after each file is processed
- 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:
| Indicator | Score |
|---|---|
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:
| Indicator | Score |
|---|---|
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.rbfiles,extend T::Sigusage - Separate indicators:
.rbifiles inrbi/orsorbet/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:
# @rbscomments or#:shorthand in.rbfiles,rbs_inline: enabledmagic comment - Separate indicators:
.rbsfiles insig/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:
| System | Style | Skill to Invoke |
|---|---|---|
| RBS | Separate | generating-rbs |
| RBS | Inline | generating-rbs-inline |
| Sorbet | Separate | generating-sorbet |
| Sorbet | Inline | generating-sorbet-inline |
For each pending [ ] entry in the tracking file (.signatures-todo.tmp):
- Read the next pending entry
- 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
- Mark the entry as processed by changing
[ ]to[x] - Save the tracking file
- 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