I have been using AI to help me code (and actually to help me do anything) for a couple of years now. More and more I keep seeing how it boosts my productivity.

When programming, I keep code suggestions minimal in the IDE and really like the chat interface for tackling coding tasks. Writing down the problem, its constraints, and the task goals in a structured way has, in my experience, shown really great results and visibly boosted my productivity. As a bonus, it has positively influenced the way I communicate about technical challenges with colleagues.

So today, I saved some time to share a simple example — the anecdotal evidence. My task was to implement the following feature in a section of our app:

• Automatically compress uploaded images

It took 25 minutes from start to finish. If I hadn’t used AI, I estimate that it would have taken me about 2 hours to search references, write down the code, test, and review before finishing this task.

👉 That’s roughly a 5x speed-up in this particular case.

Here’s a quick overview of how I structured my workflow using ChatGPT (GPT-4o model):

1. Define the Problem: I started by clearly defining my task, which was to compress uploaded images automatically in two user flows.
2. Generate Code: I asked ChatGPT to create a method for compressing images to high-quality JPEG, providing contextual code from my existing project.
3. Integrate Changes: Next, I requested ChatGPT to modify two existing image upload methods, incorporating the new compression method.
4. Create Unit Tests: Lastly, I asked ChatGPT to write a unit test for the new compression functionality following existing testing styles in the project.

Let’s take a deep dive.

The Workflow in Detail

Initially, I reviewed the source code to understand the user flows I needed to change and to locate the image upload entry points.

After getting familiar with the codebase, I concluded that the project didn’t yet define a method to compress images to JPEG. I also found an ImageExtensions class that contained several methods for performing operations on images (e.g., Rotate, Resize, Generate thumbnail, etc.), which I decided was the right place to define the new compression method.

So, in my first prompt to ChatGPT, I asked it to create the compression method, passing along additional contextual information to ensure the generated code would be compatible with my project:

using System;
using System.Drawing;
using System.Drawing.Drawing2D;
using System.Drawing.Imaging;
using System.IO;
using System.Linq;

public static Image Resize(this Image image, int newWidth, int newHeight, string url = null) 
{
    using (var newImage = new Bitmap(newWidth, newHeight))
    {
        foreach (var item in image.PropertyItems)
            newImage.SetPropertyItem(item);

        using (var graphics = Graphics.FromImage(newImage))
        {
            graphics.SmoothingMode = SmoothingMode.AntiAlias;
            graphics.InterpolationMode = InterpolationMode.HighQualityBicubic;
            graphics.PixelOffsetMode = PixelOffsetMode.HighQuality;
            graphics.DrawImage(image, new Rectangle(0, 0, newWidth, newHeight));
            var format = url != null ? GetImageFormat(url) : image.RawFormat;
            return Image.FromStream(newImage.ToStream(format));
        }
    }
}

In its response ChatGPT correctly produced the following method (I’m omitting additional information and the usage sample also returned by ChatGPT):

public static Image CompressToJpeg(this Image image, long quality = 90L)
{
    if (image == null) throw new ArgumentNullException(nameof(image));

    // Set JPEG quality encoder
    var jpegEncoder = ImageCodecInfo.GetImageDecoders()
        .FirstOrDefault(c => c.FormatID == ImageFormat.Jpeg.Guid);

    if (jpegEncoder == null)
        throw new InvalidOperationException("JPEG encoder not found");

    var encoderParams = new EncoderParameters(1);
    encoderParams.Param[0] = new EncoderParameter(Encoder.Quality, quality);

    using (var ms = new MemoryStream())
    {
        image.Save(ms, jpegEncoder, encoderParams);
        return Image.FromStream(new MemoryStream(ms.ToArray()));
    }
}

I skimmed through the code, and it seemed to implement everything I requested, so I copied and pasted the generated code into my project’s ImageExtensions class.

I continued by asking ChatGPT to adjust two of my application user flows to use the new method, with additional considerations:

    private string SaveCover(string coverName, Stream coverStream)
    {
        var path = GenerateImageName("covers", coverName);
        using (var img = Image.FromStream(coverStream))
        using (var stream = img.ToStream())
            return store.SaveObject(stream, path);
    }

    private string SaveIcon(string iconName, Stream iconStream)
    {
        var path = GenerateImageName("icons", iconName);
        using (var img = Image.FromStream(iconStream))
        using (var stream = img.ToStream())
            return store.SaveObject(stream, path);
    }

As a result, both methods were modified as requested, and ChatGPT proposed a helper method IsUncompressedImage to be used by both methods in accordance with the DRY (“don’t repeat yourself”) principle.

Here’s the final code generated by ChatGPT for one of the methods after the introduced changes:

private string SaveIcon(string iconName, Stream iconStream)
{
    var isUncompressed = IsUncompressedImage(iconName);

    var finalName = isUncompressed
        ? Path.ChangeExtension(iconName, ".jpeg")
        : iconName;

    var path = GenerateImageName("icons", finalName);

    using (var img = Image.FromStream(iconStream))
    {
        var processedImage = isUncompressed ? img.CompressToJpeg(90L) : img;
        using (var stream = processedImage.ToStream(ImageFormat.Jpeg))
        {
            return store.SaveObject(stream, path);
        }
    }
}

Again, I reviewed the code and was happy with the proposed changes. After pasting it into my application code, everything compiled without any issues.

Finally, before closing the code changes, I wanted to create a unit test for the new CompressToJpeg method, so I sent another message to ChatGPT to create the test method analogous to another test in my project:

    [TestMethod]
    public void GetGeolocatedImageCoordinateTest()
    {
        var image = Image.FromFile(@"Resources\geolocated.jpg");
        var c = image.GetCoordinate();

        Assert.IsNotNull(c);
        Assert.AreEqual($"{-22.8939933776855}", $"{c.Latitude}");
        Assert.AreEqual($"{-43.1236000061035}", $"{c.Longitude}");
    }

And voilà, the unit test was correctly created according to my request:

[TestMethod]
public void CompressToJpegTest()
{
    var image = Image.FromFile(@"Resources\Boots.png");

    using (var originalStream = new MemoryStream())
    using (var compressedStream = new MemoryStream())
    {
        // Save original image as PNG to stream
        image.Save(originalStream, ImageFormat.Png);
        var originalSize = originalStream.Length;

        // Compress to JPEG and save to stream
        var compressed = image.CompressToJpeg(90L);
        compressed.Save(compressedStream, ImageFormat.Jpeg);
        var compressedSize = compressedStream.Length;

        // Assert that the compressed image is less than 25% of the original size
        Assert.IsTrue(compressedSize < originalSize * 0.25,
            $"Expected compressed size < 25% of original. Original: {originalSize}, Compressed: {compressedSize}");
    }
}

After pasting the new test method into my test class, I was able to quickly run it and confirm that it passed 🟢.

Once I finished the code changes, I performed a manual test to validate that the task was completed:

Figure 1. Upload request in Chrome's network tab

Success!

Wrapping Up

This was just one of many examples where AI tools can turbocharge the time it takes to complete manual code structuring and fiddly tasks. This task was a great candidate because it was mostly digital plumbing, relying on high-level operations (like JPEG compression) already provided by the underlying framework.

Several studies try to capture how much productivity AI tools can bring. At the end of the day, it all depends on how frequently and how well you use them in your workflows.

As with anything, usage brings experience, and we become better at identifying the best situations and strategies for extracting productivity from these tools. A naive approach of blindly using AI in everything may backfire.

My complete conversation with ChatGPT can be accessed in the link below:

• https://chatgpt.com/share/67ed2912-af88-800b-835c-c0e0703a617f

I recently watched an interesting video titled How AI & LLMs are Shaping Financial Advice by MIT Professor Andrew W. Lo. In it, he discusses how LLMs could be used for tasks like analyzing financial reports and offering sound financial advice. He also touches on the challenges of oversight, trust and fiduciary duty, sharing his thoughts on how these issues might be addressed in the long run.

Right after that, YouTube suggested a news report from BBC about the Israel conflict in the Middle East, and that gave me an idea for an experiment. You see, we might be on the verge of an escalation in that conflict, and if it happens (I hope it doesn’t), I’m sure it’ll have a significant impact on the financial markets. I’m also sure that I’m not prepared for it, and that (again, if it happens) I’ll think in hindsight that I could have hedged against the real, though uncertain, possibility of escalation.

So in this experiment, I prepared a simple CoT (Chain-of-Thought) prompt to enlighten me about the possibilities ahead and advise me on what I could do. Let’s take a look at it below.

The prompt

The purpose of this prompt is to first explain the typical impacts of conflict escalation on the global economy. Then, it analyzes the effects on an investor’s portfolio. Finally, it seeks advice on how to balance the portfolio, considering both the chances of escalation and de-escalation (essentially as a hedge).

I think with a little more effort, we could’ve made an even better prompt. But it’s friday so let’s give this one a shot and see what we get!

The reply

There was a mix of stuff a bit obvious and some things that were new to me in the reply. But hey, sometimes the obvious needs to be said, right? Overall, I thought the info was pretty impressive. Then again, I’m not a financial analyst, so I might be falling into the Gell-Mann Amnesia effect without even realizing it.

Closing thoughts

It was a fun, quick experiment, and I learned a thing or two about global dynamics. Even though I won’t be following this advice for practical reasons, the main goal was to share it openly and get feedback from some friends in the financial sector. I also want to let it sit for a while, maybe check back in a year to see if GPT-4’s advice was somewhat valuable or just generic/simplistic fluff.

I will start this post with a direct question:

What are the most useful generative AI-powered product features you regularly use?

Think about it for a while. The answer usually includes [1]:

1. Chat apps (e.g., ChatGPT, Google Gemini)
2. Media generation tools (e.g., audio, image, video)
3. Code generation extensions (e.g., GitHub Copilot, Code Whisperer)

These are indeed very useful! But weren’t we promised that generative AI would completely change every aspect of our lives? So why can’t most of us, specially non technical people, think of more examples to answer this question? The logical answer is that they aren’t that prevalent, yet.

To add more context, it’s not that no one is trying. We’ve all seen prominent companies investing significant resources to ride the generative AI bandwagon. However, many of them decided to chase home runs instead of easy-wins, and for that reason a lot of them failed [2].

So in this post, I’ll argue that to successfully adopt generative AI in your product, you should focus on easy wins rather than home runs.

But what is an Easy-win?

An easy win, also known as a “low-hanging fruit,” can be defined as any product feature that delivers significant value to the end user while having relatively low implementation complexity:

Figure 1. Prioritization matrix

This concept originates from the prioritization matrix, a tool that helps teams manage tasks more efficiently, reduce viability risks, and optimize delivered value.

It may seem obvious to target easy wins, but more often that not we get carried away chasing shiny objects and commit to poorly assessed challenges.

How to discover gen AI easy-wins?

Considering that you may already have a working product that customers use (and love!), you should look for opportunities to improve your product’s existing user flows to make them easier, faster, and more enjoyable.

If we go back to the start of this post we can see that the gen AI apps that we use more often are those that save us time, make us more productive. Focus on that, make your customers more productive. That’s valuable.

One way I like to think of generative AI, contrary to the belief that it’s a superintelligent being, is to consider it as a very competent intern — one that can receive generic instructions and carry out low cognitive complexity tasks with reasonable precision. So, in the context of easy wins, avoid assigning your competent intern tasks that are too broad in scope, overly complex, or demand extreme precision. Those aren’t easy wins.

Additionally, anticipate and prepare for imprecise results from generative AI. If you start with a zero-tolerance policy for errors, you’re likely to fail. Instead, design your solutions to support inexpensive review and regeneration cycles. This allows end users to easily assess the quality of the output and either accept it or quickly regenerate it if necessary.

Wrapping It Up:

1. Target existing user flows
2. Search for opportunities to make your users more productive
3. Adopt gen AI for low-cognitive, narrowly scoped tasks
4. Design for inexpensive review and regeneration cycles

A concrete example

I believe it’s important to provide a real world example to illustrate how these principles can be applied in practice. At MindMiners, we offer innovative web and mobile market research solutions. Our customers create surveys on our platform and collect responses from our proprietary respondents panel via a mobile app.

One of the most time-consuming user flows on our platform is the questionnaire creation process, so we decided to focus on improving it. A common low cognitive complexity task for survey creators is listing options for multiple-choice questions based on the question text. To streamline this, we added a button for generating options.

Here’s how it looks - And of course, we took the opportunity to add some marketing flair to the icon and label there 😉:

Figure 2. Question without options

Upon clicking this button, the platform constructs a simple prompt using the question text and requests a suggestion of options from the generative AI REST API. Once a result is generated, it is inserted into the frontend:

Figure 3. Question with AI generated options

If the end user is not satisfied with the results, they can easily and quickly regenerate the question options and even provide additional instructions, such as specifying the number of options.

Closing thoughts

In this post, I outline a strategy for identifying opportunities to leverage your existing product with generative AI. Instead of pursuing overly ambitious and sophisticated features, I advocate for starting with simpler yet highly valuable improvements. I present a concrete example of a technically straightforward feature that we have developed and that was very well received by our users, demonstrating the effectiveness of this approach.

Reference

[1] Ask HN: What are some of the best user experiences with AI?

[2] Every app that adds AI looks like this