Hey everyone, Hugo here!
As a developer at Money Forward, I'm always looking for ways to optimize my workflow and become more efficient. Recently, I stumbled upon Cursor AI, and let me tell you, it’s been a total game-changer. I wanted to share my experience and dive into the technical aspects of how it's impacted my daily work.
Before Cursor AI, I often felt bogged down. Debugging those gnarly, edge-case bugs? Hours. Setting up a boilerplate for new features? Tedious. Keeping up with the latest best practices and framework updates? Exhausting. I’d find myself constantly switching between my IDE, documentation, and Stack Overflow, trying to piece everything together. It felt like my productivity was being chipped away, bit by bit.
Example: Write a method to count number of empty seats on an airplane
class Airplane
def initialize(total_seats)
@seats = Array.new(total_seats, nil) # Initialize all seats as empty
end
def count_empty_seats
empty_seats = 0
@seats.each do |seat|
empty_seats += 1 if seat.nil?
end
empty_seats
end
def assign_passenger(seat_number, passenger_name)
@seats[seat_number] = passenger_name if seat_number < @seats.length
end
end
# Example usage:
airplane = Airplane.new(10) # Create an airplane with 10 seats
airplane.assign_passenger(0, "John")
airplane.assign_passenger(2, "Mary")
puts "Number of empty seats: #{airplane.count_empty_seats}" # Output: Number of empty seats: 8This approach uses straightforward logic that’s easy to follow and doesn’t involve advanced Ruby features, design patterns, or complex structures.
After applying AI suggestions, we see improvements such as:
Applying SOLID principles
Leveraging Ruby-specific features
Adding proper error handling
Ensuring data consistency (e.g., seat count starting from 1)
The resulting code structure is as follows:
require 'forwardable'
module Airline
class Seat
attr_reader :number, :passenger
def initialize(number)
@number = number
@passenger = nil
end
def assign_passenger(passenger_name)
raise ArgumentError, 'Passenger name cannot be empty' if passenger_name.to_s.strip.empty?
raise SeatError, 'Seat is already occupied' if occupied?
@passenger = passenger_name
self
end
def empty?
@passenger.nil?
end
def occupied?
!empty?
end
def to_s
"Seat #{number}: #{occupied? ? passenger : 'Empty'}"
end
end
class Airplane
extend Forwardable
def_delegators :@seats, :size, :each, :map
class SeatError < StandardError; end
def initialize(total_seats)
raise ArgumentError, 'Total seats must be positive' unless total_seats.positive?
@seats = (1..total_seats).map { |number| Seat.new(number) }
end
def count_empty_seats
@seats.count(&:empty?)
end
def count_occupied_seats
@seats.count(&:occupied?)
end
def assign_passenger(seat_number, passenger_name)
seat = find_seat(seat_number)
seat.assign_passenger(passenger_name)
rescue SeatError => e
handle_seat_error(e, seat_number)
end
def seat_status(seat_number)
find_seat(seat_number).to_s
end
def available_seats
@seats.select(&:empty?).map(&:number)
end
def occupied_seats
@seats.select(&:occupied?).map { |seat| [seat.number, seat.passenger] }.to_h
end
def to_s
"Airplane with #{size} seats (#{count_empty_seats} empty, #{count_occupied_seats} occupied)"
end
private
def find_seat(seat_number)
@seats[seat_number - 1] || raise(SeatError, "Invalid seat number: #{seat_number}")
end
def handle_seat_error(error, seat_number)
case error
when SeatError
puts "Error assigning seat #{seat_number}: #{error.message}"
else
raise error
end
end
end
endUsage:
begin
# Create an airplane with 10 seats
airplane = Airline::Airplane.new(10)
# Assign some passengers
airplane.assign_passenger(1, "John Doe")
airplane.assign_passenger(3, "Jane Smith")
# Get various information
puts airplane.to_s
puts "\nAvailable seats: #{airplane.available_seats.join(', ')}"
puts "\nOccupied seats:"
airplane.occupied_seats.each do |seat_number, passenger|
puts " #{seat_number}: #{passenger}"
end
# Try to assign to an occupied seat
airplane.assign_passenger(1, "Bob Wilson")
# Try to assign to an invalid seat
airplane.assign_passenger(11, "Invalid Seat")
rescue StandardError => e
puts "Error: #{e.message}"
endThe code was generated by Cusor AI
This implementation is more robust, maintainable, and follows Ruby best practices. It's suitable for a production environment and can be easily extended with additional features like:
Seat classes (economy, business, first)
Passenger information management
Flight scheduling
Seat pricing
Reservation system
The code is also improved in the following areas:
Better testability
Follows the principle of least surprise
Enhanced readability and maintainability
I remember seeing Cursor AI mentioned in a developer forum. I was skeptical at first. Another AI tool making big promises? I’d seen plenty of those. But something about it piqued my interest, and I decided to take the plunge. I downloaded it, integrated it with my VS Code setup, and started experimenting.
Logo of Cursor AI
Cursor AI’s real-time code analysis is incredible. It catches syntax errors, suggests optimizations, and even points out potential security vulnerabilities I might have missed. It’s like having a senior developer constantly doing code reviews alongside me. I've noticed a significant drop in the number of runtime errors and a substantial improvement in the maintainability of my code.
Before:
def calculate_total
sum = 0
items.each do |item|
sum += item.price * item.quantity
end
sum
endAfter (with Cursor AI's suggestions):
def calculate_total
items.sum { |item| item.price * item.quantity }
endGenerating test stubs, writing API documentation, refactoring large blocks of code—these tasks used to eat up a huge chunk of my time. Now, Cursor AI handles a lot of this. For example, I can ask it to “generate unit tests for this function,” and it provides a solid starting point. This has freed up my time to focus on more complex logic and problem-solving.
Example: Method to find max number in an array
# The method finds max number in array
def find_max(arr)
arr.max
endThe unit-test that Cursor AI suggests:
require 'rspec'
# Test suite
RSpec.describe 'find_max' do
it 'returns the maximum for typical cases' do
expect(find_max([1, 2, 3])).to eq(3)
expect(find_max([-1, -5, -2])).to eq(-1)
end
it 'handles duplicate and float values' do
expect(find_max([5, 5, 3])).to eq(5)
expect(find_max([1.5, 2.7, 2.9])).to eq(2.9)
end it 'raises an error for invalid input' do
expect { find_max([]) }.to raise_error(NoMethodError)
expect { find_max(nil) }.to raise_error(NoMethodError)
end
endThe AI-powered code navigation is stellar. I can quickly jump to function definitions, find related code, and understand the dependencies between different parts of my project. This has significantly reduced the time I spend just trying to understand the codebase. Plus, the smart code suggestions have helped me explore new patterns and techniques, pushing me beyond my usual coding habits.
Example: ShoppingCart
class ShoppingCart
attr_reader :items, :total
def initialize
@items = []
@total = 0
end
# Add an item to the cart
def add_item(item)
@items << item
calculate_total
end
# Remove an item from the cart
def remove_item(item)
@items.delete(item)
calculate_total
end
# Calculate the total price
def calculate_total
@total = @items.sum { |item| item[:price] }
end
# Apply a discount to the total
def apply_discount(percentage)
@total = @total * (1 - percentage / 100.0)
end
endUsage:
def run_example
# Create a new shopping cart
cart = ShoppingCart.new
# Add some items
cart.add_item({ name: "Apple", price: 1.99 })
cart.add_item({ name: "Banana", price: 0.99 })
cart.add_item({ name: "Orange", price: 1.49 })
# Show initial total
puts "Initial total: $#{cart.total}"
# Apply a 10% discount
cart.apply_discount(10)
puts "Total after 10% discount: $#{cart.total}"
# Remove an item
cart.remove_item({ name: "Banana", price: 0.99 })
puts "Total after removing banana: $#{cart.total}"
end
# Run the example
run_exampleCursor AI doesn’t just give me the answer; it often explains why it’s suggesting a particular solution. This has been invaluable for my learning. I've been able to dive deeper into the intricacies of the frameworks and languages I use. It’s like having a tutor on demand. I've discovered new features and best practices I wasn’t even aware of before.
Example: Student
class Student
# Using attr_accessor instead of separate attr_reader and attr_writer
# This is a Ruby best practice for simple getter/setter methods
attr_accessor :name, :grades
def initialize(name)
@name = name
@grades = []
end
# Method to add a grade with validation
def add_grade(grade)
return false unless grade.between?(0, 100)
@grades << grade
true
end
# Calculate average grade using Ruby's built-in methods
def average_grade
return 0 if @grades.empty?
@grades.sum.to_f / @grades.length
end
# Get letter grade based on average
def letter_grade
case average_grade
when 90..100 then 'A'
when 80..89 then 'B'
when 70..79 then 'C'
when 60..69 then 'D'
else 'F'
end
end
endUsage:
def run_student_example
# Create a new student
student = Student.new("John Doe")
# Add some grades
puts "Adding grades..."
student.add_grade(85) # Valid grade
student.add_grade(92) # Valid grade
student.add_grade(105) # Invalid grade (will be rejected)
student.add_grade(78) # Valid grade
# Display results
puts "\nStudent: #{student.name}"
puts "Grades: #{student.grades.join(', ')}"
puts "Average: #{student.average_grade.round(2)}"
puts "Letter Grade: #{student.letter_grade}"
end
# Run the example
run_student_exampleI’ve found that my code reviews have become much more efficient. With Cursor AI helping me write clearer comments and generate more comprehensive documentation, my teammates can understand my code faster. This has led to more productive discussions and fewer misunderstandings.
For developers who want to:
Improve code quality and reduce bug
Automate tedious tasks and save time
Enhance code navigation and project understanding
Deepen their technical knowledge
Improve team collaboration
I strongly recommend giving Cursor AI a try. It's been an invaluable tool in my technical arsenal, and I think it could be for you too. If you’re using VS Code, the integration is seamless.
Cursor AI has not only changed my workflow but also how I approach coding. I’m more confident, more efficient, and more excited about the work I do. It’s been a powerful ally in my journey as a developer, and I'm eager to see how it evolves in the future.
For more information, let's Like & Follow MFV sites for updating blog, best practices, career stories of Forwardians at:
Facebook: https://www.facebook.com/moneyforward.vn
Linkedin: https://www.linkedin.com/company/money-forward-vietnam/
Youtube: https://www.youtube.com/channel/UCtIsKEVyMceskd0YjCcfvPg
