How I’m using Gen AI for my software development tasks

TLDR: Take me to the first screencast.

First things first - given how much my Gen AI usage has evolved in the last few months, I expect myself to feel embarrassed reading this post in a year or two from now. 😊

Beginning 2025, I decided to temporarily reduce my project workload to dive deeper into using Gen AI. My goal was to see what all I can use Gen AI to do beyond the regular stuff I was doing with it:

• resolving simple exceptions encountered while coding / debugging (via chatgpt.com)
• using out-of-the-box auto-complete from cursor / windsurf trials

I wanted to understand:

• what things I could ace with the help of Gen AI and what stuff I couldn’t
• the changes I needed to make in my regular workflow
• the kind of productivity + quality boost I could expect from a better use of Gen AI

The rest of this post details my experiences.

Creating ad-hoc scripts for exploratory tasks

We all get curious about a lot of random things. And for the stuff that we can’t simply answer via Google, we often have to give up because of the huge upfront effort involved in answering those curiosities. Recently, I was curious to understand how folks were using a small utility I’ve had on my website for over two years. I wanted to know things like its repeat usage, monthly usage, growth, etc. for this utility. And Gen AI did well at helping me find these out from the raw log files:

Because of the ease of creating ad-hoc scripts with Gen AI, I have found myself dabbling into many more exploratory things. And this isn’t just restricted to data analysis. It can be used to automate a lot of things we didn’t consider earlier because of the required upfront effort. Some other exploratory things I have tried:

• Screenshot and email me half a dozen infrastructure charts (across tools and platforms) I monitor daily.
• Analyze and email production errors for the day.
• Watch GitHub issues and changelogs for updates related to specific keywords for the libraries I use a lot.

For each of the above, I wrote something rudimentary upfront and have gradually improved it as I go about using them. A major shift with Gen AI is that it allows having something rudimentary running in a few minutes.

Devising the core logic

Back when I started to use Gen AI for my software development work, I mostly pasted exceptions and asked it for resolutions (a replacement for stackoverflow.com). As my usage evolved, I used auto-complete or asked Gen AI to write small snippets of code based on my pinpoint instructions. More recently, I tried to use it as a co-creator to jointly devise the logic for a certain functionality. Here’s a video snippet describing how that went:

Here’s what I learned from this experience:

• Gen AI models can be good at providing a basic framework for an algorithm if we can explain it the use case, expected input and output. In fact, I found my own thinking about the needed logic evolve as we jointly derived it.
• While the model devised the basic logic, I then spent time thinking through edge-case scenarios, testing with a wider variety of inputs, and fine-tuning the logic.
• Understanding the code took longer than that it would have taken me if I had written it myself. But the total time taken to devise the logic and implement it was less than what it would have taken me without involving the Gen AI model.

Prototyping UIs

Like the exploratory data tasks listed earlier, prototyping UI is something that we often wish we could do faster and with lower friction. Also, in setups where a UI designer isn’t available, it can be super-helpful to have a Gen AI model to ensure that the UI isn’t ugly. With this in mind, I tried to use Gen AI to improve the UI for one of my tools. Here’s how that went:

My thoughts from the experience:

• In the absence of dedicated UI expertise and tooling, Gen AI models can be super-helpful to brainstorm, quickly prototype and validate UI aspects.
• For small tools that have a limited number of screens, Gen AI models can be used to build the UI.
• Building path-breaking or original UI isn’t something Gen AI models are good at. That still requires dedicated UI expertise.
• The utility of Gen AI tools reduces (with respect to directly building UIs) for products with many UI screens. This happens because there is always a need to maintain consistency of UI components across the large number of UI screens. And, in such cases, it may be difficult to provide the Gen AI with all the needed context.

Building things with unfamiliar tech

Almost all of my Gen AI use for coding is with technologies I’m well-versed with. So, when I wanted to build something with reinforcement learning (something I had no idea about), I was curious how effectively I could use Gen AI models to do so. The following video records my experience:

Here’s what I understood from these attempts:

• The ability to throw right prompts at Gen AI models is super-critical to its effectiveness for building something. With Gen AI, the tech divide isn’t between coders and non-coders. It’s between those who can speak the needed tech and those who can’t.
• Solid tech knowhow continues to matter because prompting Gen AI in the right direction requires that technical understanding. For example - without knowing what API authorization is and why it is needed, I can’t prompt and guide Gen AI to build it for me.
• Many of us who are well-versed within our technical domains may take this for granted. But someone completely unfamiliar with a technical domain may feel inhibited when trying to use Gen AI models to build something.

Writing code for large repositories

Most of the examples in this post are for brainstorming things or building stuff on top of small functionalities, tools and repositories. Explaining things to Gen AI is simpler in such situations. But, when working on large repositories (example - over a thousand files) or products with multiple large repositories, using Gen AI effectively introduces a different set of challenges:

A few things I have experienced when trying to use Gen AI to do development related to large products:

• When I’m not well-versed with the code, I find myself using Gen AI to understand the code faster. However, even this requires me to provide it with some context (where to look at, what to look at, etc.). As a result, this always requires some pre-work and isn’t as frictionless as with smaller codebases.
• When I’m well-versed with the code, I find it easier to write the building blocks part of the code myself than explaining so many things to the Gen AI model. I can then dictate to the Gen AI model to write the small parts of the code within these building blocks.
• As a result, the larger the codebase or the product, the larger the context we need to feed to Gen AI models to be effective. And this reduces their effectiveness.

Integrating Gen AI with other tools using MCP

I have been creating Excalidraw illustrations for many years. So, I wanted to try if I could explain things to Gen AI for it to create these illustrations. But, since Excalidraw doesn’t have any inbuilt Gen AI features, I had to use MCP to achieve this. This was interesting since it also allowed me to understand the workings of MCP better. Here’s how this went:

My current understanding from this trial is that:

• MCP is super-powerful to integrate Gen AI with any software tool out there (with no changes required to be made to the software tool). So, the potential is boundless!
• Gen AI agents are good to use with the tools where we can provide the context for an action in a few words (example - send a Slack message “Service down”). But, with tools like Excalidraw, providing an accurate context and set of instructions can be cumbersome. In such situations, Gen AI models may not be useful yet.

Conclusion

Here’s the summary of my understanding from all these trials:

• Gen AI is great at building scrappy initial version of anything superfast. And we can then take over as we modify, test and fine-tune things. Given how this reduces initial friction and improves productivity, there’s no reason not to build initial version of things with Gen AI.
• The effectiveness of Gen AI is often limited by our inability to provide it with the complete context. So, in places with many UI screens, repositories, legacy aspects, running components, etc., its utility reduces. In my opinion, this is the next big frontier for Gen AI to solve with respect to its involvement in tech tasks.
• Throwing the right prompts at Gen AI to code something requires technical know-how. This means the effectiveness of Gen AI heavily depends on the knowledge of the person who drives it.

Punit Sethi

Got a web-dev pain point?

I'm an independent dev specializing in architecting React frontends, building backends with Strapi, improving web performance & scalability. To discuss your web-dev paint points, email me at punit@tezify.com.