| title | description | type | audience | purpose | rails_versions | read_time | tags | category | priority | read_order | last_updated | copyright | |||||
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
Rails Upgrade Assistant - Getting Started Guide |
Complete user documentation for using the Rails Upgrade Assistant skill, including installation, learning paths, and upgrade guidance for Rails 7.0 through 8.1 |
user-documentation |
users |
getting-started |
7.0.x to 8.1.1 |
15-20 minutes |
|
documentation |
high |
2 |
2025-11-01 |
Copyright (c) 2025 [Mario Alberto ChΓ‘vez CΓ‘rdenas] |
Version: 1.0
Created: November 1, 2025
Rails Support: 7.0.x through 8.1.1
This is a unified, intelligent Rails upgrade skill that helps you upgrade Ruby on Rails applications through any version from 7.0 to 8.1.1. Built on official Rails CHANGELOGs and integrated with MCP tools for automatic project analysis.
A comprehensive Claude skill that:
- β Analyzes your Rails project automatically using Rails MCP tools
- β Detects your current version and target version
- β Plans single-hop or multi-hop upgrade paths
- β Identifies breaking changes specific to YOUR code
- β
Preserves your custom configurations with
β οΈ warnings - β Generates comprehensive upgrade reports (50+ pages)
- β Updates files interactively via Neovim (optional)
- β Based on official Rails CHANGELOGs from GitHub
rails-upgrade-assistant/
β
βββ SKILL.md (300 lines) β Compact entry point
β βββ Overview, triggers, file references
β
βββ workflows/ π How to generate deliverables
β βββ upgrade-report-workflow.md (~400 lines)
β βββ detection-script-workflow.md (~400 lines)
β βββ app-update-preview-workflow.md (~400 lines)
β
βββ examples/ π‘ Real usage scenarios
β βββ simple-upgrade.md (~350 lines)
β βββ multi-hop-upgrade.md (~300 lines)
β βββ detection-script-only.md (~250 lines)
β βββ preview-only.md (~100 lines)
β
βββ reference/ π Quick reference
β βββ reference-files-package.md (~250 lines)
β
βββ version-guides/ π Rails version details
βββ templates/ π Report templates
βββ detection-scripts/ π Pattern definitions
Total: ~2,750 lines of well-organized content (was 1,066 lines monolithic)
version-guides/
βββ upgrade-7.0-to-7.1.md Rails 7.0.x β 7.1.x (12 changes)
βββ upgrade-7.1-to-7.2.md Rails 7.1.x β 7.2.x (38 changes)
βββ upgrade-7.2-to-8.0.md Rails 7.2.x β 8.0.x (13 changes)
βββ upgrade-8.0-to-8.1.md Rails 8.0.x β 8.1.x (8 changes)
reference/
βββ breaking-changes-by-version.md Quick lookup table
βββ multi-hop-strategy.md Multi-version planning
βββ deprecations-timeline.md What's deprecated when
βββ testing-checklist.md Comprehensive testing
Total Package Size: ~220 KB
Total Documentation: ~70 pages
Upload to Claude Project:
- Open your Claude Project
- Go to Project Settings β Knowledge
- Upload the entire
rails-upgrade-assistant/folder - Or upload just
SKILL.mdfor minimal setup
Required: Rails MCP Server
A Ruby implementation of a Model Context Protocol (MCP) server for Rails projects. This server allows LLMs (Large Language Models) to interact with Rails projects through the Model Context Protocol, providing capabilities for code analysis, exploration, and development assistance.
Optional: Neovim MCP Server (for interactive file updates)
A Ruby implementation of a Model Context Protocol (MCP) server for Neovim. This server allows LLMs (Large Language Models) to interact with Neovim through the Model Context Protocol, providing capabilities to query buffers and perform operations within the editor.
Say to Claude:
"Upgrade my Rails app to 8.1"
Claude will:
- Detect your current Rails version
- Plan the upgrade path (single or multi-hop)
- Analyze your project for custom code
- Generate comprehensive upgrade report
- Provide step-by-step instructions
- Optionally update files interactively
| From | To | Hops | Breaking Changes | Difficulty | Time | Key Changes |
|---|---|---|---|---|---|---|
| 8.0.x | 8.1.1 | 1 | 8 changes | β Easy | 2-4 hours | SSL config, bundler-audit |
| 7.2.x | 8.0.4 | 1 | 13 changes | βββ Hard | 6-8 hours | Propshaft, Solid gems |
| 7.1.x | 7.2.3 | 1 | 38 changes | ββ Medium | 4-6 hours | Transaction jobs, PWA |
| 7.0.x | 7.1.6 | 1 | 12 changes | ββ Medium | 3-5 hours | cache_classes, SSL |
| 7.0.x | 8.1.1 | 4 | All 71 changes | ββββ Very Hard | 2-3 weeks | Multi-hop required |
Rails upgrades MUST be sequential:
β
Correct: 7.0 β 7.1 β 7.2 β 8.0 β 8.1
β Wrong: 7.0 β 8.0 (skips 7.1, 7.2)
β Wrong: 7.1 β 8.0 (skips 7.2)
If you request a multi-hop upgrade (e.g., 7.0 β 8.1), Claude will:
- Explain the sequential requirement
- Plan all intermediate hops
- Generate separate reports for each hop
- Guide you through completing each hop before moving to next
Best for: Understanding what needs to change before making any edits
Usage:
"Upgrade my Rails app from 7.2 to 8.0"
Claude will:
- Call
railsMcpServer:project_infoto detect current version - Load appropriate version guide(s)
- Analyze your project files for custom code
- Identify breaking changes affecting YOUR code
- Generate comprehensive upgrade report with:
- Executive summary
- Breaking changes (HIGH/MEDIUM/LOW priority)
- OLD vs NEW code examples
β οΈ Custom code warnings- Step-by-step migration guide
- Testing checklist
- Rollback plan
You remain in control: Review the report and apply changes manually.
Best for: Experienced users who want live file updates
Requirements:
- Files open in Neovim
- Neovim socket at
/tmp/nvim-{project_name}.sock - Neovim MCP server connected
Usage:
"Upgrade to Rails 8.1 in interactive mode with project 'myapp'"
Claude will:
- Generate full upgrade report (like Mode 1)
- Check which files are open in Neovim via
nvimMcpServer:get_project_buffers - For each file needing changes:
- Show current code (OLD)
- Show proposed code (NEW)
- Ask: "Should I update this file?"
- If yes: Use
nvimMcpServer:update_bufferto update - If no: Skip and note you can apply manually
- Verify each change applied successfully
- Summarize all changes made
Safety features:
- β Shows changes BEFORE applying
- β Requires approval for each file
- β Checks buffer availability
- β Never modifies files you haven't opened
- β Preserves custom configurations
Best for: Specific questions about changes
Examples:
"What ActiveRecord changes are in Rails 8.0?"
β Shows only ActiveRecord-related changes
"How do I handle the SSL configuration change?"
β Shows detailed SSL migration steps
"What breaking changes affect my models?"
β Analyzes your models and shows relevant changes
"Show me all configuration file changes for 7.2"
β Filters for config updates in Rails 7.2
"Will my Redis cache work after upgrading to 8.0?"
β Checks Solid Cache changes and provides guidance
The skill automatically uses these Rails MCP tools to understand YOUR project:
railsMcpServer:project_infoExtracts:
- Current Rails version from Gemfile
- Project structure (API-only? Full stack?)
- Rails root directory
- Ruby version
railsMcpServer:list_files
directory: "config"
pattern: "*.rb"Lists:
- Configuration files
- Models, controllers, jobs
- Initializers
- Custom middleware
railsMcpServer:get_file
path: "config/application.rb"Reads files to:
- Detect custom configurations
- Find deprecated patterns
- Identify custom middleware
- Check for manual overrides
railsMcpServer:analyze_models
model_name: "User"Analyzes:
- Model associations
- Validations
- Custom scopes
- Callbacks
railsMcpServer:get_schema
table_name: "users"Reviews:
- Database tables
- Column types
- Foreign keys
- Indexes
railsMcpServer:get_routesMaps:
- All HTTP routes
- Controllers and actions
- Custom routes
- Middleware chains
"I'm new to Rails upgrades. Guide me through everything!"
Steps:
- Read: This README (10 min)
- Read: QUICK-REFERENCE.md (15 min)
- Read: Relevant version guide in
version-guides/(30 min) - Execute: Follow the step-by-step guide in version guide (4-8 hours)
- Test: Use testing checklist from
reference/testing-checklist.md(2-3 hours)
Time Investment: 55 minutes prep + 6-11 hours execution
Outcome: Successful upgrade with full understanding
"I've done Rails upgrades before. Give me the essentials."
Steps:
- Scan: QUICK-REFERENCE.md (5 min)
- Say to Claude: "Upgrade my Rails app to [version]" (1 min)
- Review: Generated report breaking changes section (15 min)
- Execute: Apply changes using report as guide (3-6 hours)
- Test: Run test suite and fix issues (1-2 hours)
Time Investment: 20 minutes prep + 4-8 hours execution
Outcome: Efficient upgrade with minimal friction
"I need to upgrade across multiple major versions."
Steps:
- Read:
reference/multi-hop-strategy.md(15 min) - Say to Claude: "Plan upgrade from Rails [old] to [new]" (2 min)
- Review: Claude's hop-by-hop strategy (10 min)
- Execute: Complete each hop sequentially (1-3 weeks)
- Test: Full testing between each hop (2-4 hours per hop)
Time Investment: 30 minutes planning + 1-3 weeks execution
Outcome: Safe multi-version upgrade with clear progression
"I need to know what's involved before committing."
Steps:
- Say to Claude: "Assess upgrade impact from [version] to [version]" (1 min)
- Review: Generated executive summary (10 min)
- Read:
reference/breaking-changes-by-version.mdfor your path (15 min) - Check: Custom code warnings in report (10 min)
- Decide: Create timeline and resource plan (10 min)
Time Investment: 45 minutes
Outcome: Clear understanding of scope, risk, and timeline
HIGH IMPACT:
- SSL configuration now commented out (affects non-Kamal deploys)
- Database
pool:renamed tomax_connections: - bundler-audit script required
MEDIUM IMPACT:
- Query parsing changes (semicolons removed)
- Some job adapters moved to gems
Time: 2-4 hours | Difficulty: β Easy
HIGH IMPACT:
- Asset pipeline: Sprockets β Propshaft
- Solid gems: New defaults for cache/queue/cable
- Multi-database config required for Solid gems
MEDIUM IMPACT:
- Docker/Kamal integration
- Health check endpoint added
- Development SSL changes
Time: 6-8 hours | Difficulty: βββ Hard
HIGH IMPACT:
- Transaction-aware job enqueuing (behavior change!)
ActiveRecord::Base.connectiondeprecatedshow_exceptionschanged from boolean to symbolRails.application.secretsremoved
MEDIUM IMPACT:
- PWA manifest support
- Browser version checking
- Multiple ActionMailer/ActiveRecord deprecations
Time: 4-6 hours | Difficulty: ββ Medium
HIGH IMPACT:
cache_classesβenable_reloading(inverted logic!)- Force SSL now default in production
- SQLite database moved to
storage/
MEDIUM IMPACT:
lib/autoloaded by default- ActionMailer preview path plural
- Query log format changed
Time: 3-5 hours | Difficulty: ββ Medium
REQUIRES: 4 sequential hops (7.0β7.1β7.2β8.0β8.1)
CUMULATIVE IMPACT:
- All breaking changes from each version
- Multiple configuration migrations
- Significant architectural changes
- Extensive testing required
Time: 2-3 weeks | Difficulty: ββββ Very Hard
See: reference/multi-hop-strategy.md for detailed planning
The skill automatically detects and warns about customizations:
β οΈ Custom SQLite path detected in config/database.yml
Current: database: db/development.sqlite3
Rails 7.1+: database: storage/development.sqlite3
Action: Review and update pathβ οΈ Custom SSL middleware detected in config/application.rb
Line 23: middleware.use CustomSSLMiddleware
Rails 7.1+: May conflict with config.force_ssl = true
Action: Review compatibility and remove if redundantβ οΈ Custom autoload_paths in config/application.rb
Line 15: config.autoload_paths << Rails.root.join('lib')
Rails 7.1+: lib/ autoloaded by default (config.autoload_lib)
Action: Remove manual path, may cause naming conflictsβ οΈ Explicit cache format version in config/application.rb
Line 28: config.cache_format_version = 7.0
Rails 7.1+: Can upgrade to 7.1 after full deployment
Action: Consider upgrading format for performanceβ οΈ Custom Sprockets processors detected
Files: lib/assets/processors/custom_minifier.rb
Rails 8.0+: Propshaft doesn't support processors
Action: Migrate to different approach or keep Sprocketsβ οΈ Manual Redis configuration in config/initializers/
File: config/initializers/redis.rb
Rails 8.0+: Solid Cache may replace manual Redis setup
Action: Consider migrating to Solid Cache or keep customEvery breaking change includes
Before starting any upgrade:
- All tests currently passing (unit + integration + system)
- Database backed up (test restore procedure!)
- Application under version control (git with clean working directory)
- Staging environment available for testing
- Rollback plan documented (can you rollback in < 5 minutes?)
- Team notified of upgrade schedule and potential downtime
- Error tracking configured (Sentry, Honeybadger, etc.)
- Rails MCP server connected and tested
- Current version confirmed (run
bin/rails -v) - Dependencies reviewed (check for gem compatibility)
- Custom code documented (know what you've customized)
- Monitoring dashboards ready (watch performance post-deploy)
- Communication plan (how to notify users if issues arise)
- Neovim MCP for interactive mode (if using advanced features)
- Read full version guide (for your specific upgrade path)
- Review deprecation warnings in current version
- Plan time for optimization (use new features, improve code)
The skill uses dedicated workflow files to generate each deliverable:
-
Upgrade Report β Generated using
workflows/upgrade-report-workflow.md- Provides step-by-step template population instructions
- Ensures consistent, high-quality reports
- Includes custom code detection patterns
-
Detection Script β Generated using
workflows/detection-script-workflow.md- Converts YAML patterns to bash code
- Creates automated scanning scripts
- Includes pattern validation
-
App:Update Preview β Generated using
workflows/app-update-preview-workflow.md- Identifies config files to update
- Generates before/after comparisons
- Integrates with Neovim for live updates
Each workflow file is loaded on-demand, ensuring Claude has detailed, focused instructions for generating that specific deliverable.
Every upgrade request generates a detailed report:
1. Executive Summary
- Current and target versions
- Number of breaking changes
- Estimated time
- Risk assessment
β οΈ Custom code warnings count
2. Project Analysis
- Your Rails version and structure
- Files that need updating
- Custom configurations detected
- Gemfile dependencies
3. Breaking Changes (Prioritized)
- HIGH Priority: Will cause app to fail
- MEDIUM Priority: Should address soon
- LOW Priority: Optional improvements
4. Code Examples (OLD vs NEW)
# OLD (Rails 7.2)
config.action_dispatch.show_exceptions = true
# NEW (Rails 7.2 - will error on old syntax)
config.action_dispatch.show_exceptions = :all
# WHY: Symbol format provides finer control
# IMPACT: β οΈ If custom exception handling middleware, review compatibility5. Custom Code Warnings (
- All detected customizations listed
- Specific files and line numbers
- Migration guidance for each
- Compatibility concerns
6. Step-by-Step Migration Guide
- Phase-by-phase breakdown
- Time estimates per phase
- Testing checkpoints
- Rollback procedures
7. Testing Checklist
- Unit test guidance
- Integration test scenarios
- System test coverage
- Manual testing checklist
- Performance benchmarks
8. Deployment Strategy
- Staging deployment steps
- Production deployment plan
- Monitoring guidance
- Rollback triggers
9. Official Resources
- Links to Rails guides
- CHANGELOG references
- Community resources
Don't start making changes until you understand the complete scope. The report is designed to be read from start to finish.
Apply one change β test β commit β repeat. Don't make all changes at once.
# Good workflow
git checkout -b rails-upgrade
# Apply change 1
bin/rails test
git commit -am "Change 1: Update Gemfile"
# Apply change 2
bin/rails test
git commit -am "Change 2: Update config"Especially for major version jumps (7.2 β 8.0), test thoroughly in staging before production.
Watch error rates, performance metrics, and user feedback closely for 24-48 hours after production deployment.
Your rollback should be tested and executable in < 5 minutes. Practice it in staging first.
For multi-version upgrades, complete each hop entirely (including production deploy and monitoring) before starting the next hop.
Keep notes on what worked, what didn't, and any custom workarounds. This helps future upgrades.
Address all HIGH priority breaking changes before touching MEDIUM or LOW priority items.
Solution:
# Verify installation
npm list -g rails-mcp-server
# Reinstall if needed
npm install -g rails-mcp-server
# Check Claude configuration
cat ~/.config/Claude/config.json
# Verify "rails" is in mcpServersSolution:
- Ensure you're in Rails project root
- Verify Gemfile exists
- Check
gem 'rails'line in Gemfile - Manually tell Claude: "My Rails version is X.Y.Z"
Solution:
- Neovim must be running
- Check socket exists:
ls /tmp/nvim-*.sock - Verify project name matches socket name
- Try report-only mode first
- Check Neovim MCP server installation
Solution:
This is normal! The skill is being thorough. Focus on:
- HIGH priority warnings first
- Warnings in files you actually use
- Ignore warnings for files you plan to remove
Solution:
- Ask Claude: "My tests are failing with [error message]"
- Check
TROUBLESHOOTING.mdfor your error - Review the breaking changes section for your upgrade
- Verify you applied all required changes
Solution:
This is the Sprockets β Propshaft migration. See:
version-guides/upgrade-7.2-to-8.0.mdβ Asset Pipeline section- Check
app/assets/config/manifest.jsexists - Verify asset paths in views
- Review
TROUBLESHOOTING.mdβ Assets section
File: QUICK-REFERENCE.md
Contents:
- Command cheat sheet
- Breaking changes summary
- Quick troubleshooting
- Common patterns
- Time estimates
Use when: You need fast lookup during active upgrade work
File: USAGE-GUIDE.md
Contents:
- Detailed installation
- 30+ example prompts
- 4 complete workflows
- Best practices
- Advanced features
Use when: Learning the skill or complex upgrade planning
File: TROUBLESHOOTING.md
Contents:
- Common errors & solutions
- Error message lookup
- Debugging strategies
- Recovery procedures
Use when: Something went wrong and you need to fix it
Location: version-guides/
Files:
upgrade-7.0-to-7.1.md(70+ pages)upgrade-7.1-to-7.2.md(90+ pages)upgrade-7.2-to-8.0.md(85+ pages)upgrade-8.0-to-8.1.md(85+ pages)
Contents:
- Complete CHANGELOG analysis
- All breaking changes with OLD/NEW examples
- Component-by-component changes
- Migration steps
- Testing procedures
Use when: Executing a specific version upgrade
Location: reference/
Files:
breaking-changes-by-version.md- Quick lookup tablemulti-hop-strategy.md- Multi-version upgrade planningdeprecations-timeline.md- What's deprecated whentesting-checklist.md- Comprehensive testing guide
Use when: You need specific reference information
Location: examples/
Files:
simple-upgrade.md- Single-hop walkthroughcomplex-multi-hop.md- Multi-version upgrade examplecustom-code-handling.md- Preserving customizations
Use when: You want to see real-world upgrade scenarios
Your upgrade is successful when:
- Application boots without errors
- All routes respond correctly
- Assets load properly (CSS, JS, images)
- Database queries execute correctly
- Background jobs process successfully
- Caching works as expected
- WebSockets/ActionCable functions
- Authentication/authorization works
- Third-party integrations work
- Email delivery functions
- All tests pass (100% of previous passing tests)
- No deprecation warnings in logs
- Test coverage maintained or improved
- Performance metrics stable or better
- No memory leaks detected
- No N+1 query regressions
- Staging deployment successful
- Production deployment successful
- No error spikes in error tracking
- Monitoring dashboards healthy
- Users not reporting issues
- Rollback procedure tested and documented
- Deployment docs updated
- Setup instructions updated
- Team trained on changes
- Runbooks updated
- CI/CD pipeline verified
- Reads YOUR actual project files
- Understands YOUR customizations
- Provides personalized guidance
- Not generic advice
- All recommendations from Rails CHANGELOGs
- Verified against GitHub sources
- Up-to-date with latest releases
- Not based on blog posts or opinions
- Never modifies without permission
- Always provides rollback plans
- Includes comprehensive testing
- Warns about customizations
- Report-only: For careful review
- Interactive: For rapid iteration
- You choose based on comfort level
- Prevents version skipping
- Plans multi-hop upgrades correctly
- Guides through each hop
- Ensures safe progression
- Automatically detects customizations
- Marks with
β οΈ warnings - Provides specific guidance
- Helps maintain your code
Quick answers:
β QUICK-REFERENCE.md
Detailed guidance:
β USAGE-GUIDE.md
Troubleshooting:
β TROUBLESHOOTING.md
Specific version:
β version-guides/upgrade-X-to-Y.md
Just ask! Examples:
"How do I use this skill?"
"What's the difference between the two modes?"
"Explain this breaking change in detail"
"Help me with this error: [error message]"
"Show me an example of [specific task]"
"What files do I need to update?"
"How long will this upgrade take?"
Rails Guides: https://guides.rubyonrails.org
Rails Upgrading Guide: https://guides.rubyonrails.org/upgrading_ruby_on_rails.html
Rails GitHub: https://github.com/rails/rails
Rails Forum: https://discuss.rubyonrails.org
Rails Discord: https://discord.gg/rails
Coverage:
- Rails 7.0.x β 7.1.6
- Rails 7.1.x β 7.2.3
- Rails 7.2.x β 8.0.4
- Rails 8.0.x β 8.1.1
- Multi-hop: Any path through above versions
Based On:
- Official Rails CHANGELOGs from GitHub
- rails-new-output diffs from railsdiff.org
- Real-world upgrade experience
- Community feedback
- Rails Versions: 7.0.x through 8.1.1 (5 versions)
- Breaking Changes: 71 documented across all versions
- Code Examples: 150+ OLD/NEW comparisons
- Commands: 50+ ready-to-use commands
- Warnings: 100+ custom code warnings
- Core Files: 5 files (~50 KB)
- Version Guides: 4 files (~320 KB)
- Reference Materials: 4 files (~30 KB)
- Examples: 3 files (~20 KB)
- Total: ~420 KB of documentation
| Upgrade Path | Read Time | Prep Time | Execution | Testing | Total |
|---|---|---|---|---|---|
| 8.0 β 8.1 | 30 min | 30 min | 2-4 hrs | 2-3 hrs | 5-8 hrs |
| 7.2 β 8.0 | 45 min | 1 hr | 6-8 hrs | 3-4 hrs | 11-14 hrs |
| 7.1 β 7.2 | 30 min | 45 min | 4-6 hrs | 2-3 hrs | 7-10 hrs |
| 7.0 β 7.1 | 30 min | 30 min | 3-5 hrs | 2-3 hrs | 6-9 hrs |
| 7.0 β 8.1 | 2 hrs | 2 hrs | 2-3 wks | 1 wk | 3-4 wks |
- Install the skill in your Claude Project
- Verify Rails MCP server is connected
- Choose your path from the Learning Paths section
- Say to Claude:
"Upgrade my Rails app to [version]" - Review the report carefully
- Follow the steps one by one
- Test thoroughly at each stage
- Deploy with confidence
- π Read documentation thoroughly
- π§ͺ Test extensively before production
- πΎ Always have backups
- π Have rollback plan ready
- π₯ Communicate with your team
- π Monitor closely after deployment
This skill package is created to help the Rails community upgrade safely and efficiently. Copyright (c) 2025 Mario Alberto ChΓ‘vez CΓ‘rdenas
Rails is a trademark of the Rails Core Team. Claude is a product of Anthropic.
All Rails upgrade information is based on official Rails CHANGELOGs from the Rails GitHub repository.
Created with:
- Official Rails CHANGELOGs from GitHub
- Rails MCP server for intelligent project analysis
- Neovim MCP server for interactive file updates
- Rails diff data from railsdiff.org
Found this skill helpful? Have suggestions for improvement?
- Use the feedback button in Claude interface
- Share with the Rails community
- Contribute improvements back
Questions? Just ask Claude:
"How do I start using this Rails upgrade skill?"
"Show me an example upgrade"
"What should I read first?"
"Explain [specific concept]"
The journey of 1,000 commits begins with a single command:
"Upgrade my Rails app to [version]"
Happy upgrading! π
README Version: 1.0
Last Updated: November 1, 2025
Skill Version: 1.0
Package Version: Rails Upgrade Assistant