Can Regular People Code Now? My Journey from Skeptic to Builder

My journey in AI began a little over a decade ago with machine learning. back then, it was purely a tool for recognizing patterns and structures in data—invaluable for tasks like commissioning renewable power plants or optimizing battery sizing based on energy consumption.

The next stop was deep neural networks and machine vision. Fuelled by the self-driving car revolution, this technology made analyzing images and video reasonably simple. Suddenly, satellite imagery or live video streams could be ingested and processed by small on-site computers, like the Nvidia Jetson Nano.

Then, in 2023, Large Language Models (LLMs) arrived. At first glance, the performance was impressive, though often marred by "hallucinations." From a business perspective, it looked promising, but I remained skeptical: was this just a fancy search engine, or perhaps a glorified translator?

To find the answer, I spent the last few months diving deep into LLMs—specifically from the perspective of a guy who cannot code.

I am resurfacing now with a wealth of new knowledge, a few painful experiences, and a fresh perspective on the corporate utility of LLMs. In my context, LLMs fall into two distinct buckets:

1. The Application: Software solutions that utilize LLMs to deliver business value.

2. The Build: The actual tools used to create that software.

Let’s focus on the latter. Can I, with no background in coding, build my own software?

The simple answer is yes.

I have identified three main approaches to doing this: No-Code Automation, Hosted "Vibe Coding", and Agentic IDEs.

1. No-Code Automation (The Integrator)

Tools tested: n8n, Make, Zapier.

These tools allow you to build workflows using visual nodes. Tools like n8n are particularly powerful because they are built on solid open-source frameworks like LangChain, making the underlying code for flows and agents very robust.

The Experience: Most of what I initially needed could be done here. However, the downside is that you still need to understand system logic. Building a web scraper is possible, but you must figure out exactly which nodes to use. While AI helpers exist within these tools, they tend to gravitate toward paid third-party solutions and cannot "invent" new nodes for you.

• Pros: Great for "If X, do Y" logic.

• Cons: Complex logic becomes a hassle; reliability issues arise with scale; no native Front-End/UI (you are stuck connecting to Google Sheets, Forms, or relying on external UIs).

Winner: n8n (for its deep integrations and open template approach).

• Verdict: Excellent for backend logic, but not a complete software solution alone.

Apps I built with n8n:

• RAG Pipeline: Connected to Google Docs for document retrieval.

• Blog Post Writer: An automated flow tied to a Lovable front-end, Google Forms, and Hubspot for publishing.

2. Hosted "Vibe Coding" Solutions

Tools tested: Lovable, Base44, Riff.

As the name implies, these are hosted environments that provide an "Agentic IDE." You prompt, and they handle the code and hosting. Lovable focuses on glossy, consumer-facing apps with a "prototype" feel, while Riff targets enterprise customers building internal tools.

The Experience: While impressive, my challenge is that neither solution is ready for a corporate environment. They are still stuck in a "single developer/startup" mindset. I encountered four specific governance gaps:

1. Fragmentation: I wanted a unified look and feel across all apps with a shared admin dashboard. Currently, I am forced to build one massive app to achieve this, as I cannot monitor or theme multiple small apps centrally.

2. Architecture Drift: I want a "system prompt" at the account level to enforce architectural standards (e.g., "Always use Airtable for database," "Always use LangSmith for monitoring"). Without this, the AI hallucinates a new tech stack for every app.

3. API Key Management: There is no centralized .env file. I have to manually paste API keys (Gemini, OpenAI) into every single app. A centralized secret manager with user-level access controls is a must-have for business use.

4. Black Box Frameworks: These tools often "vibe code" without a declared framework. I want to instruct the builder to use LangGraph for complex agents to ensure the code is trustworthy and stable. If the user doesn't know to ask for this, the output is random and potentially unstable.

Winner: Riff (due to its focus on internal business tools).

• Verdict: Promising, but I hope they solve the governance issues above.

Apps I built with Riff:

• Deep Research Agent: A 5-agent system in LangGraph with LangSmith tracing. Four agents conduct research (via Tavily) and fact-checking, while the fifth segments leads and updates the CRM (Hubspot).

• Web Monitor/Scraper: Monitors key pages, stores data in Airtable, and works with a Lead Identifier agent.

3. The Agentic IDE (The Powerhouse)

Tools tested: Visual Studio Code (Copilot), Kiro (Amazon), Anti Gravity (Google).

This is the most powerful but also the most complex category. Cursor started this trend, but the field is evolving rapidly. These systems differ from hosted solutions because you are closer to the raw code.

The Experience: Development happens at lightning speed. I tested Kiro early on, but eventually jumped to Anti Gravity as it introduced significant improvements.

Like the hosted solutions, these tools are immature but improving daily. The major advantage here is control—things like .env files and API keys are much easier to manage. However, you need to know what to ask for, and you must verify that the agent hasn't "forgotten" early instructions during long sessions.

The biggest historical hurdle here has been deployment, but this is being solved.

Winner: Anti Gravity (by a significant margin). Three features set it apart:

1. Browser Testing: The agent can actively click and test the app in a web browser to verify its own code.

2. Parallel Agents: You can have multiple agents working simultaneously, allowing them to maintain shorter, more focused context windows.

3. Direct Deployment: Seamless integration with Google Run and Kubernetes.

Apps I built with Kiro:

• IoT Edge App: An Edge Lambda application in a Greengrass runtime, deployed to a Raspberry Pi 5.

• Local AI App: Running on a laptop with local LLM support.

Apps I built with Anti Gravity:

• AI Hub: A suite of 8 connected apps.

• Backstage Automation: A set of 4 separate agents handling background tasks.

• Meeting Support: A Chrome extension for live meeting assistance.

• Voice Agent: An app integrating ElevenLabs for voice conversation.

What’s Next? In the following blog posts, I will break down each of these apps in detail—sharing exactly how they were made, the specific prompts used, and how they are performing in the real world. Stay tuned.