generating-rbs-inline
Generates RBS-inline type annotations directly in Ruby source files as comments. Triggers when adding inline type signatures, annotating Ruby methods with rbs-inline syntax, or generating type comments without existing inline annotations.
Best use case
generating-rbs-inline is best used when you need a repeatable AI agent workflow instead of a one-off prompt.
Generates RBS-inline type annotations directly in Ruby source files as comments. Triggers when adding inline type signatures, annotating Ruby methods with rbs-inline syntax, or generating type comments without existing inline annotations.
Teams using generating-rbs-inline should expect a more consistent output, faster repeated execution, less prompt rewriting.
When to use this skill
- You want a reusable workflow that can be run more than once with consistent structure.
When not to use this skill
- You only need a quick one-off answer and do not need a reusable workflow.
- You cannot install or maintain the underlying files, dependencies, or repository context.
Installation
Claude Code / Cursor / Codex
Manual Installation
- Download SKILL.md from GitHub
- Place it in
.claude/skills/generating-rbs-inline/SKILL.mdinside your project - Restart your AI agent — it will auto-discover the skill
How generating-rbs-inline Compares
| Feature / Agent | generating-rbs-inline | Standard Approach |
|---|---|---|
| Platform Support | Not specified | Limited / Varies |
| Context Awareness | High | Baseline |
| Installation Complexity | Unknown | N/A |
Frequently Asked Questions
What does this skill do?
Generates RBS-inline type annotations directly in Ruby source files as comments. Triggers when adding inline type signatures, annotating Ruby methods with rbs-inline syntax, or generating type comments without existing inline annotations.
Where can I find the source code?
You can find the source code on GitHub using the link provided at the top of the page.
SKILL.md Source
# RBS-Inline Generation Skill
Generate RBS-inline type annotations as comments directly in Ruby source 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.
## 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:
```ruby
# rbs_inline: enabled
```
2. Then add type annotations as comments directly in the Ruby source file using rbs-inline syntax:
**Example - Before:**
```ruby
class User
attr_reader :name, :age
def initialize(name, age)
@name = name
@age = age
end
def greet(greeting)
"#{greeting}, #{@name}!"
end
end
```
**Example - After:**
```ruby
# 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](reference/syntax.md) for the full RBS-inline syntax guide
- Pay extra attention to `Data` and `Struct` types
- See [data-struct-support.md](reference/data-struct-support.md) for Data and Struct handling
## 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:
```bash
rbs-inline --output lib
```
This generates `.rbs` files in `sig/generated/` directory.
2. Validate the generated RBS files:
```bash
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:
```bash
rbs-inline --output lib
```
2. Run Steep type checker:
```bash
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
- [syntax.md](reference/syntax.md) - RBS-inline syntax guide
- [data-struct-support.md](reference/data-struct-support.md) - Data and Struct handling in rbs-inline
- [examples/](reference/rbs_inline_examples/STRUCTURE.md) - Real-world rbs-inline examples from production gems
- [rbs-inline repository](https://github.com/soutaro/rbs-inline) - Official rbs-inline gemRelated Skills
generating-unit-tests
This skill enables Claude to automatically generate comprehensive unit tests from source code. It is triggered when the user requests unit tests, test cases, or test suites for specific files or code snippets. The skill supports multiple testing frameworks including Jest, pytest, JUnit, and others, intelligently detecting the appropriate framework or using one specified by the user. Use this skill when the user asks to "generate tests", "create unit tests", or uses the shortcut "gut" followed by a file path.
generating-test-reports
This skill generates comprehensive test reports with coverage metrics, trends, and stakeholder-friendly formats (HTML, PDF, JSON). It aggregates test results from various frameworks, calculates key metrics (coverage, pass rate, duration), and performs trend analysis. Use this skill when the user requests a test report, coverage analysis, failure analysis, or historical comparisons of test runs. Trigger terms include "test report", "coverage report", "testing trends", "failure analysis", and "historical test data".
generating-test-doubles
This skill uses the test-doubles-generator plugin to automatically create mocks, stubs, spies, and fakes for unit testing. It analyzes dependencies in the code and generates appropriate test doubles based on the chosen testing framework, such as Jest, Sinon, or others. Use this skill when you need to generate test doubles, mocks, stubs, spies, or fakes to isolate units of code during testing. Trigger this skill by requesting test double generation or using the `/gen-doubles` or `/gd` command.
generating-test-data
This skill enables Claude to generate realistic test data for software development. It uses the test-data-generator plugin to create users, products, orders, and custom schemas for comprehensive testing. Use this skill when you need to populate databases, simulate user behavior, or create fixtures for automated tests. Trigger phrases include "generate test data", "create fake users", "populate database", "generate product data", "create test orders", or "generate data based on schema". This skill is especially useful for populating testing environments or creating sample data for demonstrations.
generating-stored-procedures
This skill uses the stored-procedure-generator plugin to create production-ready stored procedures, functions, triggers, and custom database logic. It supports PostgreSQL, MySQL, and SQL Server. Use this skill when the user asks to "generate stored procedure", "create database function", "write a trigger", or needs help with "database logic", "optimizing database performance", or "ensuring transaction safety" in their database. The skill is activated by requests related to database stored procedures, functions, or triggers.
generating-orm-code
This skill enables Claude to generate ORM models and database schemas. It is triggered when the user requests the creation of ORM models, database schemas, or wishes to generate code for interacting with databases. The skill supports various ORMs including TypeORM, Prisma, Sequelize, SQLAlchemy, Django ORM, Entity Framework, and Hibernate. Use this skill when the user mentions terms like "ORM model", "database schema", "generate entities", "create migrations", or specifies a particular ORM framework like "TypeORM entities" or "SQLAlchemy models". It facilitates both database-to-code and code-to-database schema generation.
generating-infrastructure-as-code
This skill enables Claude to generate Infrastructure as Code (IaC) configurations. It uses the infrastructure-as-code-generator plugin to create production-ready IaC for Terraform, CloudFormation, Pulumi, ARM Templates, and CDK. Use this skill when the user requests IaC configurations for cloud infrastructure, specifying the platform (e.g., Terraform, CloudFormation) and cloud provider (e.g., AWS, Azure, GCP), or when the user needs help automating infrastructure deployment. Trigger terms include: "generate IaC", "create Terraform", "CloudFormation template", "Pulumi program", "infrastructure code".
generating-smart-commits
This skill generates conventional commit messages using AI analysis of staged Git changes. It automatically determines the commit type (feat, fix, docs, etc.), identifies breaking changes, and formats the message according to conventional commit standards. Use this when asked to create a commit message, write a Git commit, or when the user uses the `/commit-smart` or `/gc` command. It is especially useful after changes have been staged with `git add`.
generating-trading-signals
Generate trading signals using technical indicators (RSI, MACD, Bollinger Bands, etc.). Combines multiple indicators into composite signals with confidence scores. Use when analyzing assets for trading opportunities or checking technical indicators. Trigger with phrases like "get trading signals", "check indicators", "analyze for entry", "scan for opportunities", "generate buy/sell signals", or "technical analysis".
generating-rest-apis
Generate complete REST API implementations from OpenAPI specifications or database schemas. Use when generating RESTful API implementations. Trigger with phrases like "generate REST API", "create RESTful API", or "build REST endpoints".
generating-helm-charts
Execute use when generating Helm charts for Kubernetes applications. Trigger with phrases like "create Helm chart", "generate chart for app", "package Kubernetes deployment", or "helm template". Produces production-ready charts with Chart.yaml, values.yaml, templates, and best practices for multi-environment deployments.
generating-grpc-services
Generate gRPC service definitions, stubs, and implementations from Protocol Buffers. Use when creating high-performance gRPC services. Trigger with phrases like "generate gRPC service", "create gRPC API", or "build gRPC server".