ProductMagic

We dove into the fine print, and it quickly became clear why a simple comparison wasn't enough. The part-payment conditions were a tangled web of clauses, varying wildly between lenders. It wasn't simply a matter of comparing interest rates; it was about understanding the cost of flexibility. Here are some examples of the complexities we encountered:

• Variable Part Payment Fees: Some lenders charged fees that scaled with the loan tenure. For instance, a 3% fee might apply if a part payment was made between the 12th and 24th month of the loan, dropping to 2% after 24 months. This meant the optimal prepayment strategy depended heavily on when you made the payment.
• Minimum and Maximum Prepayment Amounts: Most lenders imposed minimum prepayment amounts, often tied to a multiple of the monthly EMI (e.g., a minimum of 3 EMIs). This prevented small, frequent prepayments. Additionally, some lenders capped the maximum prepayment amount, either as a fixed sum or a percentage of the outstanding principal (e.g., 25%).
• Timing Restrictions: Some loans prohibited prepayments altogether within the first 12 months. Others limited the frequency of prepayments, such as allowing only one prepayment per financial year or a maximum of two during the entire loan tenure.
• Example: Lender A vs. Lender B: To illustrate, Lender A might have offered a slightly higher interest rate (14%) but allowed unlimited prepayments (subject to minimum amounts and timing restrictions). Lender B, on the other hand, offered a lower rate (11.75%) but restricted prepayments to a maximum of 25% of the outstanding principal and only twice during the loan term. This contrast highlighted the trade-off between interest rate and prepayment flexibility.

This intricate interplay of factors made manual calculations impractical and underscored the need for a dynamic tool.

Diving into GenAI for Code - A Learning Journey

I decided to use this challenge as a real-world test for GenAI's code generation capabilities, specifically using Google's Gemini. My goal wasn't to build a polished, production-ready app, but rather to gain insights into how GenAI could assist in the coding process. The context was building a loan calculator to handle the above complexities.

This experiment provided some valuable lessons about using GenAI for coding:

• The Prompting Challenge (Lesson: Precision is Key): Initially, my prompts were too general. I quickly realized that GenAI thrives on specific instructions. For example, when asking it to incorporate the variable part-payment fees based on loan tenure, I had to provide a very detailed breakdown of the logic: "If the prepayment is made between month 12 and 24, apply a 3% fee; if between 25 and 36, apply a 2% fee; otherwise, no fee." The more precise the prompt, the more accurate and relevant the generated code.
• Debugging and Iteration (Lesson: GenAI is a Partner, Not a Replacement): While GenAI could generate code snippets quickly, it wasn't always perfect. I encountered logical errors, such as incorrect calculations or mishandled conditional statements. This meant spending time debugging and iteratively refining my prompts. This highlighted that GenAI is a powerful assistant, but human oversight and coding knowledge are essential. For instance, in one instance, the generated code was comparing years to months in the prepayment logic, leading to incorrect results. I had to explicitly point out this error in a subsequent prompt.
• Data Representation (Lesson: Guiding Data Structures): A key challenge was guiding GenAI to represent the complex loan terms effectively in the code. I had to explicitly prompt it to use dictionaries to store the prepayment conditions (fees, minimum amounts, restrictions). While it could generate the basic data structure, it initially struggled to use these structures correctly in the calculations. It would sometimes use hardcoded values instead of referencing the dictionary, showing it wasn’t always aware of the code it had previously generated.
• Unexpected Discoveries (Lesson: GenAI Can Offer Suggestions): In some cases, GenAI suggested code improvements or alternative approaches that I hadn't initially considered. This demonstrated its potential not just to generate code but also to offer insights and potentially improve code quality.

The Resulting Code (GitHub)

If you're interested in seeing the code that resulted from this GenAI experiment, you can find it on GitHub pages.

Key Takeaways for Using GenAI for Code

• Precise prompts are paramount: The more detail you provide, the better the results.
• GenAI is an assistant, not a replacement for coding skills: Human oversight, debugging, and logical reasoning are still crucial.
• GenAI can accelerate development but requires careful validation: Thorough testing is essential to catch errors and ensure the code functions as intended.
• GenAI can offer unexpected insights and suggestions: It can be a valuable tool for exploring different coding approaches.
• Iterative prompting is key: Be prepared to refine your prompts based on the generated code.

Conclusion

This exploration of GenAI for code generation was a valuable learning experience. It highlighted the power of this technology while also underscoring the importance of human guidance and critical thinking. GenAI has the potential to transform software development, but it's the combination of human expertise and AI assistance that will truly unlock its full potential.