Skip to main content

Generics<T>

· 3 min read
Milad

Ever asked AI to generate code for you and ended up needing to tweak it over and over again for different use cases? There's a better way.

Table of Contents​

AI-assisted code generators give short-term solutions by default.

How you can guide it to produce a long-term, reusable solution instead?

Introduction to Generics​

🚀 Target audiences: Anyone who writes Code

How AI Code Generators Work: A Simple Example​

🤔 Consider this:

If you ask AI to write a function that finds the max element in an array, it might generate something like:

In TypeScript:

function maxNumber(arr: number[]): number { ... }

In Rust:

fn max_number(arr: &[i32]) -> Option<i32> { ... }

These work, but they’re limited to numeric types.

A more scalable prompt would be:

Write a function that finds the max element in an array for any data type that supports comparison.

This would result in: In TypeScript:

function maxElement<T>(arr: T[]): T { ... }

In Rust:

fn max_element<T: Ord>(arr: &[T]) -> Option<&T> { ... }
Disclaimer

The generated codes are for illustrations only. in production there are some nuances you should consider. For example, in Rust, what if T only implements PartialOrd and not Ord? A more flexible approach might involve T: PartialOrd and handling the None case when comparison is undefined.

🔑

We just used Generics!

Why Should Code Be Scalable?​

Generics ensure that you don’t need to rewrite code every time a new type or use case emerges.

1️⃣ AI Can Generate Code, But Can It Generate Good Abstractions? AI is excellent at providing immediate solutions, but it lacks the intuition to know when to use generics or concrete types.

2️⃣ When to Rely on AI for Generics vs. When to Write It Yourself

  • Use AI when implementing well-known generic patterns (like sorting, filtering, or mapping)
  • Write yourself when designing domain-specific abstractions
  • Combine both approaches for complex systems where some parts are standard and others are unique

Let AI handle the boilerplate but maintain control over your core business logic.

3️⃣ Why Non-Technical Users Should Care About Generics

warning

Even if you're not a programmer but using AI-generated code, you should care about generics because:

  • Scalability: You won’t have to repeatedly ask AI to "change this function for strings."
  • Error Reduction: Non-generic AI code can result in unexpected type errors when inputs change.
  • Lower AI Dependence: Generics reduce the number of times you need AI to regenerate similar code.

5️⃣ AI Models are conceptually Using Generics

Neural networks generalize patterns across different types of data, similar to how generics allow functions to work with multiple types. They apply the same mathematical operations to different types of input.

Now You Should Have an Idea of Why Abstractions (Generics) are needed.​

💡 Final Thought: Generics Make AI More Useful, Not Just Convenient

Next time you write or prompt AI for code, remember:

tip

Are you asking AI for a quick fix, or designing a reusable, scalable solution?

Leverage AI to build smarter, more scalable systems that evolve with your needs. 🚀 That’s the difference between using AI like a shortcut and leveraging AI like a powerful tool. 🚀

End of Article