From Frustrated Founder to Hands-on Engineer: How AI Made the Difference

Breaking Free: Learning Coding Basics 🧑‍🎓

Have you ever had a vision of how a specific thing should look and work but explaining it in all details would take 10x more time than showing a working prototype?

That was me a few years ago, stuck in a cycle familiar to many founders—projects bogged down by long deadlines for seemingly simple tasks, endless meetings to nail down rigid requirements, and final products that didn’t truly serve our users or the company.

Frustrated by the inefficiencies and misalignments, I decided to take matters into my own hands. I began learning to code, transforming myself into a technical founder.

I started with resources like Automate the Boring Stuff with Python and Learn JavaScript the Hard Way. Within weeks, I was:

• Creating scripts: First script was to pull publicly available contact numbers a large number of websites 📊
• Working with APIs: Using Google oAUTH to create simple logins, testing other services 🔑
• Building simple apps: I started by building blogs and directories 🛠️

Within months, I was actively contributing to our own codebase, making informed decisions quickly, and implementing features that truly served our users and the company.

The Power of Autonomy

In many companies, team members are hindered by:

• Rigid Instructions: Strict guidelines that leave little room for innovation. 🚫
• Fear of Repercussions: A culture where stepping outside defined roles could upset management. 😟
• Lack of Decision-Making Authority: Inability to make swift decisions that could benefit the project.🚶‍♂️

As a founder with technical skills and deep insight into our company’s priorities, I could bypass these hurdles. I made hundreds of micro-decisions on the fly, leading to efficient and effective solutions that aligned perfectly with our goals.

Supercharging with AI 🚀

Thanks to advances in AI—especially Large Language Models (LLMs)—becoming a technical founder is more accessible than ever. Over the past year, AI has been my “junior developer,” helping me expand beyond Python and MERN to languages and frameworks like Java, Kotlin (Android), Objective-C/Swift (iOS), Go, and even browser extensions. 

Recently, I built a quickstart tool that generates code for our developer partners in just 2-3 hours—a task that might have taken my team three days or more. 

In this article, I’ll share my journey and processes to inspire more founders to take a hands-on approach when it matters, even if you’re not a full-time developer.

‍Choosing the Right Project ⚖️

It’s important to choose projects wisely when leveraging LLMs.

1. Stick to established technologies:
   • LLMs are trained on historical data, so they perform better with established tech. For example, using Node.js, which has been around for over a decade, ensures that most issues have known solutions. However, with newer tools like Supabase, I found the instructions generated by ChatGPT to be lacking, forcing me to figure it out manually.
2. Don’t expect the best implementation:
   • LLMs can provide functional solutions, but they may not be the most efficient or scalable. For non-critical features, it’s often fine as long as the outputs are correct. However, for core systems, you may need to dive deeper to refine the solution.
3. Be specific with your prompts:
   • A detailed prompt is crucial, much like defining product requirements upfront. Taking the time to clarify expectations early on can save significant time down the road, preventing costly rewrites and misaligned results.

Building the Prompt

I’m no prompt expert, but through trial and error, I’ve learned a few tricks to get better outputs from LLMs. In this case, I was building a proxy command generator so developers could enter some parameters and then copy/paste code into their Terminal and get successful responses. After browsing examples online, I took a screenshot of a similar tool and wrote my initial prompt in a text editor:

Here is a screenshot of a proxy command generator. Can you tell me in detail what you see?

The LLM returned a detailed breakdown of the proxy generator’s features, but not all of them were relevant. I simplified it to include only the essential features we needed, such as targeting options and protocol selection. 

Here’s what I refined the prompt to:

I need help crafting a quickstart guide for a developer dashboard used by partners to generate requests through a residential proxy network.

The guide should cover the following parameters:

Targeting Options: Default or filtered (country, state, city, zip).
Type: Rotating or sticky proxies.
Protocol: HTTP, HTTPS, or SOCKS5.

[Example cURL requests for each of these configurations]

Implementation & Troubleshooting

The first response from the LLM included a rough JavaScript implementation of the quickstart guide. While the structure was there, it wasn’t quite right—visually, it was clunky, and some features didn’t work. Here’s a screenshot of one of the the first versions (the first version was way worse looking, but I forgot to save a screenshot of it):

‍

‍

After reviewing the output, I provided feedback to fine-tune the implementation:

• HTTP and HTTPS needed to be separated, using different ports.
• The “Save Configuration” button was unnecessary and could be replaced by a “Copy” button.
• Dropdowns for country and state selection required autocomplete features for ease of use.
• Other small adjustments, like background color changes, enhanced the user experience.

Over the next couple of hours, I used the LLM for all the tedious tasks, such as generating dropdown options and fixing minor bugs. For example, I had the LLM create lists of country codes and US states, and it also helped troubleshoot the “Clear Configuration” button, which wasn’t functioning properly at first.

While the LLM was instrumental in completing basic tasks, some work required domain knowledge, such as:

• Creating a new tab in the sidebar.
• Setting up routes for the new page.
• Injecting user-specific credentials (proxy username and API key) into the curl commands.

By Monday morning, the feature was live after a quick review. Here’s the final version of the proxy generator:

‍

Lessons Learned

This project was a great example of how LLMs can accelerate development for founders with some coding experience. The LLM handled most of the groundwork, and I stepped in where technical expertise was needed.

🔑 Key takeaways:

1. LLMs excel with established technologies but they struggle with newer technologies and complex issues.

• Detailed prompts greatly enhance output quality.
• LLMs can increase speed but may sacrifice quality and/or scalability. They don’t always produce the most optimized code, but they can help founders move fast and focus on core business priorities.
• Having some technical understanding makes a huge difference. Learn the fundamentals of how applications work and the relationship between database, API, and front-end so you can guide LLM coding assistants and troubleshoot problems.

‍

In just a few hours, I was able to build and deploy a feature that would have taken my team days. For founders like me, leveraging LLMs allows us to tackle technical challenges, save time, and keep the business moving forward.

Closing Thoughts

Learning to code transformed my role as a founder, but incorporating AI into my workflow has taken it to the next level. 

I hope this walkthrough helps other founders clear the mental hurdle of becoming technical and also realize the potential of AI-driven development. Tools like LLMs are making it easier than ever to bring your ideas to life.