Evaluating top AI app builders

I’ve spent the past many months deep in the trenches with AI app builders, watching this space explode in 2025. I’ve poked and prodded at dozens of tools that promise to turn natural language into working software. Some delivered delightful surprises; others, not so much. In this article, I’ll share my hands-on impressions of the top AI app building platforms, organized by category. We’ll cover everything from AI code generators to form builders to autonomous agents. I’ll be frank about what it was like to build with each, where they shine, where they stumble, and how they fit into a real development workflow (beyond the hype). If a tool isn’t fully reviewed yet, I’ll note it as “review coming soon” as I plan to keep this updated as these platforms evolve.

Let’s dive in and see which of these AI co-builders have earned a place in a developer’s toolkit (and which are on thin ice).

AI code generators

AI pair programmers that generate actual code from natural language. These tools aim to speed up coding by producing code snippets or even entire project scaffolds based on prompts. They range from “chat with an AI to build an app” services to IDE extensions that autocomplete your code. After testing these, I’ve found they’re fantastic for jumpstarting projects and boilerplate, though each has its quirks and limits.

1. Lovable

What it is: Lovable (aka LOVABLE AI) is a prompt-driven app builder that turns plain English descriptions into full-stack web applications. Think of it as an AI software engineer that you chat with about your app idea. It then generates the React frontend, a Supabase backend, and even wires up auth and database if you ask. The acronym LOVABLE stands for “Letting Ordinary Visionaries Achieve Breakthroughs with Language-based Engineering,” which reflects its mission of making app creation accessible. (baytechconsulting.combaytechconsulting.com)

Building with it: My first time using Lovable was a positive experience. I described a simple “to-do list app with user sign-up and a task dashboard,” and it spawned a React/Tailwind UI and a Supabase PostgreSQL schema for tasks. The speed really is insane for prototyping. Iterating was conversational: “Now add a filter to only show my tasks” resulted in an updated UI with a filter dropdown. Under the hood, it creates code (React + Vite project) and pushes it to a GitHub repo, so I could pull the code and tweak it manually when needed. This two-way workflow (AI generation plus manual editing) is a big plus. It shines for quickly scaffolding an MVP or admin panel.

Advantages: 

1. Rapid prototyping: It dramatically shortens the dev setup time. I had a basic, functioning app in seconds where traditionally I’d spend hours on boilerplate. It’s ideal for MVPs and hackathon-style projects.
2. Full-stack integration: Lovable isn’t just a toy frontend generator; it sets up a Supabase backend (Postgres DB, auth, file storage, etc.) automatically. That means the apps it generates can persist data, manage users, etc., out of the box. 
3. Standard tech stack: I appreciated that it uses popular frameworks (React, Tailwind, Supabase) rather than some proprietary engine. The code quality was fairly clean and aligned with common practices, making it easier to hand off to a dev team later (or to continue developing myself). 
4. GitHub integration: Lovable can commit code to your repo, which provides transparency and version control. I never felt “locked in” could always eject and edit the code on my own IDE.

Limitations: 

1. Credit-based pricing and iteration friction: Lovable runs on a credit system, so every prompt or app generation consumes credits. On the free tier, I hit the limits quickly when refining my app. Even some paid tiers have usage caps. In one session, after a dozen back-and-forth refinement prompts, I got a warning that I was nearing my quota. It makes you a bit nervous about iterating too much. If your project is complex and requires many adjustments, costs can add up. 
2. No true backend logic beyond what Supabase offers: While it sets up CRUD and auth nicely, any custom server-side logic (beyond Supabase’s serverless functions) wasn’t really in scope. It’s not (yet) an AI that will write complex algorithms or integrations for you, you might end up writing that part yourself after the scaffold.
3. Security concerns: An independent review in April 2025 highlighted that Lovable could potentially be misused to generate malicious apps (like phishing sites) if prompts are abused. They dubbed this vulnerability “VibeScamming”; an AI could unknowingly scaffold a convincing scam UI. Lovable has since added some guardrails (and I got a warning when I experimentally prompted it with something sketchy, as a test). Still, it’s a reminder that these AI dev tools need content filtering.
4. UI editing finesse: The platform has a visual editor to tweak the generated UI, but I found it a bit clunky for fine-tuning layouts. Simple things, like adjusting spacing or swapping out a component, sometimes required additional prompts because direct drag-and-drop editing was limited. In short, it’s great for the first 90% of the app, but that last 10% polish; you may end up doing it in code or waiting for Lovable’s next update.

Where it fits: Lovable is perfect at the ideation and prototyping stage. When I need an interactive mockup or a v1 product to test an idea, it’s my go-to. Startups and solo builders can get an MVP in front of users fast. It also serves as a bridge between designers and developers, a product manager can whip up a concept app without coding, then hand the code to devs to harden it. I wouldn’t (yet) use Lovable to generate a final, large-scale production app all on its own; complex logic or scaling considerations are beyond its scope. But for early-stage development, it’s a huge accelerator.

2. Bolt

What it is: Bolt (accessible at bolt.new) is another AI-powered development environment for generating full-stack apps. It’s often seen as a direct alternative to Lovable. The key difference: Bolt runs entirely in your browser and is designed to be fast. The interface splits into a chat-like prompt panel on the left and a live code preview on the right (ref: thepromptwarrior.com). Instead of manually coding, you describe features and Bolt writes the code in real-time, showing you the resulting app instantly. It supports choosing a starting framework (like a Next.js blank project, etc.) and can do one-click deploys to the web.

Building with it: Using Bolt felt like having a super-charged ChatGPT. I followed a simple workflow the first time:

(1) Selected “Start with blank Next.js app” from Bolt’s menu, (2) Typed a prompt “Create a note-taking app with a title field and markdown support,” and (3) watched Bolt generate the code and spin up the app preview. In literally 2 minutes I had a running web app (and yes, I could type notes in it!). Hitting the Deploy button pushed it live via a Netlify integration, no configuration needed. The whole experience is like ChatGPT combined with a lightweight IDE and a deployment pipeline.

Editing code in Bolt is technically possible (you can click into the code it generated), but the UI nudges you to prompt rather than hand-edit. It feels more like a no-code tool in that sense, I found myself iterating by telling the AI what to change (“Make the notes sortable by date” etc.) instead of typing code. That’s great for non-programmers or quick tries, though as a programmer I occasionally wanted to fine-tune the code directly and the editor wasn’t super friendly for that. Bolt is clearly optimized for “type instructions, not code.”

Advantages: 

1. Fast scaffolding & deployment: As mentioned, Bolt is the quickest way I’ve seen to go from zero to a live web app. It automates all the setup (choose your framework, then it handles dependencies, file structure, etc.) and hosting. With Bolt’s built-in deployment, I had a shareable URL of my app with literally one click. In contrast, with some IDE-based tools I’d have to copy code to Vercel or similar to deploy. This is a huge win for hackathons or internal demos. 
2. Beginner-friendly UI: The Bolt interface feels like a familiar chat or like using ChatGPT, which is less intimidating than opening a full IDE. A friend with minimal coding experience tried it and loved that she didn’t have to “see code” unless she wanted she could just describe features and watch them appear. It lowers the entry barrier for making small apps or prototypes. 
3. Great for UI scaffolding: Bolt excelled at creating the basic UI and connecting common services. It had templates for things like simple CRUD apps, and it could integrate things like a Stripe payment button or a Google Maps component if you prompt correctly. It felt like it had a toolbox of components and recipes to draw from, making it adept at standard web app patterns.

Limitations: 

1. Not suited for complex apps: When I pushed Bolt beyond simple to-do-list complexity, it started to flounder. In one test, I attempted a more complex inventory management app with user roles, batch operations, etc. Bolt began making mistakes, it would produce code with errors, then try to fix them in a loop, sometimes regressing or getting confused. This aligns with what others have noted: Bolt is awesome for quick scaffolds, but “good luck building something more complex with it!”, it tends to run into errors and self-fix loops on larger projects. In my case, after a certain point I had to stop and export the code to a regular editor to finish the job. 
2. Limited code editability in-app: The Bolt editor is minimal. If Bolt’s AI writes something slightly off, there is not a rich editing or debugging environment to step in and tweak. The expected use is you keep prompting the AI to change the code. While that’s fine for high-level changes, it was frustrating for small fixes, e.g. I wanted to adjust a single CSS rule, and doing that via a prompt (“make the header blue”) sometimes caused the AI to regenerate more than I wanted. Essentially, control is limited. As an advanced user, I felt constrained when I needed a specific edit. The workaround is to export the project to Stackblitz’s full editor or download it, but that breaks the flow. 
3. No backend beyond serverless functions: Bolt can set up a Next.js or Express backend for simple API routes, but it doesn’t provide database integration by default (unlike Lovable with Supabase). You’d have to manually connect a database or use an API. So it’s more front-end heavy. For persistent data beyond session/demo, you must incorporate external services. 
4. Pricing model: Currently Bolt is free (in beta), but it’s unclear how they’ll charge long-term. If they impose usage limits or a subscription, one will have to consider cost vs. using a free open-source template + Copilot.

Where it fits: Bolt is my favorite for throwaway prototypes and quick demos. When I need to prove an idea in minutes or create a small utility app, I reach for Bolt. It’s like a super rapid WYSIWYG for web apps. I also sometimes use Bolt to kickstart a project’s skeleton, then immediately export to a dev environment for serious development. For example, I’ll have Bolt lay out a basic Next.js project with a couple pages (to save me the boring setup), then I’ll take over in VS Code + Cursor for the heavy lifting. Bolt is less useful for large, production-bound projects, except as a starting boost. I see it as a complement to more robust tools: use Bolt to get the basic skeleton (fast UI and deployment), then switch to a full IDE or another AI coding assistant for the deeper logic and maintenance. 

3. GitHub Copilot

What it is: GitHub Copilot needs little introduction at this point, it’s the AI coding assistant integrated into VS Code (and other IDEs). I’ve been using Copilot since its early days, and by 2025 it has evolved significantly. It acts like an AI pair programmer: it autocompletes lines or whole functions as you code, and with the newer “Copilot Chat” and Copilot CLI/Agent modes, it can also follow natural language instructions (inside your editor) to refactor code or even run multi-step dev tasks. Essentially, Copilot is baked into your coding workflow, rather than replacing it.

Building with it: My experience with Copilot is different from the likes of Lovable or Bolt, Copilot doesn’t generate an entire app from a blank prompt. Instead, it’s there with me as I write code. For example, I start writing a function in Python to parse some data, and Copilot suggests the rest of the logic almost like an autocomplete. It often correctly infers what I’m trying to do (from the function name or comment) and gives me a draft of the code. With Copilot Chat (released as part of “Copilot X” upgrades), I can highlight a block and ask, “Hey, optimize this loop” or “Find the bug here,” and it responds in the sidebar with code changes or explanations. By mid-2025, Copilot even introduced an “agent mode” in VS Code that can take higher-level objectives (e.g. “Create a new component and unit test for feature X”) and attempt to execute them, somewhat like Cursor’s agent did. Microsoft has integrated these features deeply, I’ve seen Copilot suggest pipeline configurations, documentation, even SQL queries based on my database schema. The scope of what Copilot covers in development keeps growing.

Advantages: 

1. Embedded in my workflow: Copilot lives in VS Code while I code, which means I don’t have to switch contexts. This is huge for productivity. Compared to using an external chat tool (like ChatGPT web or Lovable) and copy-pasting code, Copilot feels seamless. 
2. Highly consistent for code completion: Over time, I’ve noticed Copilot’s suggestions have gotten more reliable. It’s trained on tons of public code, so for standard tasks it’s eerily good. Writing boilerplate or repetitive code is now something I rarely do manually, Copilot fills in the blanks 80% of the time with minimal edits needed. Users have found it consistently solid: one review noted that Copilot (especially with GPT-3.5/4 models) provides steady, dependable completions day-to-day. I agree, it might not always hit bulls-eye on the first try, but it rarely spits out something completely off-base.
3. Reduced cognitive load: I can focus on what I want to achieve, and Copilot figures out the how in code syntax. For instance, I can write a comment “// sort list of events by date desc” in JavaScript, and Copilot will write the sort function. It’s not just saving keystrokes; it’s saving me from having to recall exact API names or language quirks. It’s like having Google/StackOverflow knowledge contextually as I code.
4. Now with multi-step “agent” capabilities: A big development in 2025 is that Copilot isn’t limited to one-file suggestions. GitHub (and Microsoft) rolled out a preview where Copilot can perform multi-file refactors or create new files on command (in VS Code Insiders). I played with this “agent mode”, for example, I typed a natural language command to “Add a new route and controller for user profiles” in a Node.js app. Copilot proceeded to generate a new file, modify the routing config, and suggest relevant code in each place. It’s not always perfect, but it felt like having a junior dev who takes a first pass at a multi-file change. This closed much of the gap that existed between Copilot and a more autonomous tool like Cursor or Cody. In fact, by this point Copilot and Cursor have converged in capabilities, both have chat and agentic features for coding tasks.

Limitations:

1. IDE-specific and not a full app generator: Copilot is fantastic when I’m in coding mode, but it won’t design your app from scratch via conversation. It’s not a replacement for something like Lovable if you have zero code and just an idea, instead, you need to have a project and start writing code, then Copilot assists. So non-developers might find it less immediately gratifying. It’s really a developer’s tool.
2. Quality depends on context and codebase: In a new or poorly documented codebase, Copilot has less to go on. I noticed that when I work on proprietary or very unique code, Copilot’s suggestions are hit-or-miss because it doesn’t “know” the context beyond what I’ve written. It shines with familiar patterns and frameworks. Also, earlier in 2025 Copilot’s context window was expanded (especially if using GPT-4 model under the hood), which helped it consider more of my code at once. However, it still sometimes loses the thread on very large files or projects.
3. Costs and limits: GitHub Copilot is a paid subscription ($10/month for individuals), which is reasonable given how much time it saves me. They did implement some usage limits: I read that as of May 2025, they introduced a cap of ~300 requests per month on the highest tier model, presumably to control costs. In normal use I personally haven’t hit a hard limit, but extremely heavy users might. Meanwhile, competing IDE assistants like Cursor charge more (Cursor is about $20/mo and even then caps “fast” requests), so Copilot still feels like good value. 
4. Still makes mistakes: It must be said, Copilot can and does generate errors. It might use an outdated API or a wrong variable name occasionally. I’ve had instances where it confidently wrote a function with a subtle bug. So you cannot blindly trust it. It requires the developer’s oversight and testing. Think of it as a helper that writes 80% correct code, and you are responsible for the remaining 20% fixes and validation. It won’t magically handle complex new logic you don’t understand; it usually needs guidance or corrections from you for those scenarios.

Where it fits: GitHub Copilot is a must-have in the coding stage of app development for me. It’s not about prototyping a whole app (use other tools for that); it’s about day-to-day coding productivity. When I’m writing actual production code, Copilot is my constant companion. It speeds up implementing features, writing tests, generating boilerplate (like DTOs, config files, etc.), and even helps in learning new frameworks by example. It’s most beneficial to developers who are actively coding, it won’t replace understanding system design or requirements, but once I know what I need to build, Copilot makes the act of writing the code much faster and less tedious.

4. Cursor IDE

What it is: Cursor is an AI-powered code editor, basically an entire IDE built around an AI assistant. Imagine VS Code, but with a chat sidebar that has deep knowledge of your project, and the ability to make project-wide changes via prompts. That’s Cursor. It gained popularity in late 2024 as one of the first IDEs to tightly integrate an AI agent (Claude by Anthropic, in fact) into the coding workflow. By 2025, Cursor has become a strong competitor to Copilot, especially for those who wanted more autonomy from the AI and a dedicated environment for AI-assisted coding. I’ve been using Cursor for some of my projects to compare it with Copilot.

(Review coming soon)

5. Claude 3.5 (Anthropic “Sonnet”)

What it is: Claude 3.5 (nicknamed “Claude-Sonnet” for the version tuned for coding) is Anthropic’s latest large language model, which many tools (like Cursor) use as their AI brain. While not a product with a user interface by itself, I’ve interacted with Claude 3.5 via other apps and via API. It’s known for huge context windows and a cooperative, less deterministic style. Some devs use Claude in Slack or other chat interfaces as a coding aide, similar to how one would use ChatGPT.

(Review coming soon)

6. DeepSeek V3

What it is: DeepSeek V3 is the dark horse in the AI world that emerged out of China and caught everyone’s attention in 2025. It’s a massive 600+ billion parameter Mixture-of-Experts model (with about 37B active per token), and it’s available through an app and open-source weights. DeepSeek made headlines for reportedly outperforming models like Meta’s Llama and even challenging GPT-4 on certain benchmarks. It went viral when their mobile chatbot app topped app store charts globally. So naturally, I was intrigued to see how DeepSeek handles coding tasks and app building.

(Review coming soon)

7. ChatGPT (GPT-4.5)

What it is: ChatGPT, the trusty AI chatbot that started it all, is still very much in my arsenal for coding and app building. By late 2024, OpenAI rolled out GPT-4.5 (an intermediate upgrade to GPT-4), and I’ve been using ChatGPT with GPT-4 (and presumably 4.5) throughout 2025. It’s worth covering here because ChatGPT effectively acts as an AI app builder when used well: you can converse with it to generate code, solve errors, and even use plugins or the Code Interpreter (renamed Advanced Data Analysis) to run code.

(Review coming soon)

Low-code AI app builders

AI copilots for low-code platforms. In this category, we have platforms that traditionally offer drag-and-drop app building (for web or mobile internal tools), now supercharged with AI to generate complete or parts of the app for you. These are great for those who don’t want to write raw code for everything. You define data models and UIs in a GUI, and the AI helps fill in the gaps (or even builds entire modules from a prompt). I spent time with several low-code builders that rolled out AI features in 2025. Overall, they accelerate the tedious parts of app assembly, though the experience can vary depending on how well the AI integrates with the platform’s components and what the vendors have sought to solve. Let’s go through the notable ones I’ve tried:

8. DronaHQ AI

What it is: DronaHQ is a low-code internal tools platform (think dashboards, admin panels, CRUD apps) that added a robust AI App Builder component this year. Essentially, it combines their mature low-code environment with generative AI to allow users to build apps by describing them in natural language or Vision AI. It gives you the speed of AI-generated apps with the structure and maintainability of low-code. 

Building with it: I had an existing database of customer orders and wanted to quickly build an admin panel to view and search orders. Normally, in DronaHQ, you would drag out a UI component, say a table grid, connect it to the database, configure queries, etc. With DronaHQ AI, you instead open their AI chatbot interface inside the builder and type: “Build an order management dashboard: list of orders with filter by date and status, and a form to update an order’s status with @ Database” The AI goes to work, within about 30 seconds, it generates a BRD that you scan through and approve or reject. It then generated two screens: one had a table component bound to my Orders table, complete with filter controls for date and status. The second screen had a form with fields for the order details and a dropdown for status, and even a “Save” button that was wired to an update query. It is a pixel-perfect and functional starting app. It also used DronaHQ’s standard components and best practices: e.g., it used their pre-built table component and form controls, not some custom HTML.

After a generation, I switched to the visual editor (this is not exactly switching, as the AI chatbot is baked into the platform’s visual editor console). All the components were there, and I could manually tweak them (change labels, reposition things) with drag-and-drop. The AI had pre-bound the data: the table’s data source was set to my Orders DB query, and the form’s fields were mapped to selected row from the table. Normally, doing those bindings by hand is the somewhat tedious part in low-code; here, it was done for me. I did have to refine a bit: the filter by date was initially just a text field, so I replaced it with a date picker component. Interestingly, these tweaks are also AI-powered. I could just tag the UI component and ask AI to update it. I told the AI chatbot, “make the date filter use a date picker” and it actually did adjust it to a date picker control and updated the query binding to filter correctly. That felt like pair-programming inside a UI builder.

One more test: I tried their Vision AI feature, where you upload a design file (I exported a simple form screen from Figma). DronaHQ AI analyzed the image and generated a UI layout in the app matching it, using their standard controls. It got the layout about 90% correct. I had to add an image carousel, but it was still a time-saver versus building from scratch.

Advantages: 

1. Maintains low-code structure: This is DronaHQ AI’s big selling point. The output isn’t some black-box code or one-off HTML, it’s composed of DronaHQ’s vetted components and connectors. That means after AI generation, your app is maintainable. I can continue to use the normal DronaHQ builder on it. When I generate an app, it follows a design system, uses proper data bindings, etc. In my use, I noticed the generated UI had consistent styling and spacing using our company’s theme that I’d configured. It felt production-quality, not just a throwaway prototype. 
2. Two modes of building, prompt or visual, are interchangeable: Seamlessly go from AI chat to manual editing and back. For example, I generated a screen by prompt, then I manually added a chart component, then I asked the AI to “bind this chart to show total orders by day”; it understood my existing component and wrote the query for it. That synergy was great. It’s not AI-only; it’s AI plus low-code together. 
3. Data integration out of the box: DronaHQ connects to tons of databases and APIs. The AI leverages that, when I started a prompt, I can tell it which data source to use. Once I picked my Postgres DB, the AI could actually see the schema (it asked me to confirm table names in its BRD). It then formed queries under the hood. It basically eliminated the configuration steps by inferring what I wanted. Since it’s built on the low-code platform, it automatically handled details like auth, deployment, user roles from the platform’s settings, stuff that code-gen tools would ignore.
4. Pricing and self-hosting flexibility: They have a pricing model for AI credits (e.g. $30/month for 2000 AI credits. I could also connect my own OpenAI API key and use that, which is nice.

Limitations: 

1. Domain knowledge is limited to your prompt clarity: The AI doesn’t magically know your business rules unless you express them. In my order dashboard example, I had to specifically prompt for the features I needed. If I was too vague (“make an order dashboard”), initially it made some assumptions that weren’t quite right (it included a “Create Order” form which my use case didn’t need). I had to iterate with the prompt. For a more complex domain (say a compliance audit tool with specific logic), I suspect I’d still spend time refining the AI output. It accelerates the build, but you must guide it well. 
2. Occasional layout quirks: The generated UIs were generally good, but sometimes the layout needed tweaking. One time it chose a slightly odd component (e.g., it used two dropdowns for a range filter where maybe a single slider would have been better). These weren’t huge issues; low-code means I could fix it with drag-and-drop easily. But it’s not always a perfect one-shot generation, expect to polish the UI a bit.
3. Focus on internal tools use cases: DronaHQ AI is fantastic for CRUD apps, admin panels, forms, etc., basically internal tools. If you wanted to build, say, a public-facing mobile app like Amazon or a highly custom UI, that’s outside its scope. It’s not trying to be a consumer app builder. So the limitation is in the domain it serves. For my needs (mostly internal web apps), that was fine.

Where it fits: DronaHQ AI really shines in quickly standing up internal business applications. In the app lifecycle, it’s perfect for the initial development of tools that might otherwise take a backend dev + frontend dev several days to set up. With DronaHQ AI I got a functional app in minutes that I could then hand over to a team or end-users for feedback. It’s also useful for routine internal apps, those things like admin panels that every company needs. Instead of spending valuable dev time, an ops person could almost build it themselves with AI assistance. I also see it being used for iteration: if an app needs a new module or report, I can generate it quickly and plug it in. Importantly, DronaHQ ensures the AI-generated stuff isn’t throwaway, it’s a living app I can maintain. So I’d use it not just for a demo, but as the foundation of the real tool (with some verification before production, of course). Among all the AI app builders I’ve tried, DronaHQ AI felt the most grounded in practical usage, it wasn’t flashy sci-fi, it was like “here’s your app, it’s built following the same rules your devs would follow.” That goes a long way in making me trust it for serious use.

9. ToolJet AI

What it is: ToolJet is a popular open-source low-code platform for internal tools (similar to DronaHQ in concept). In 2025, ToolJet introduced AI features to their builder, often referring to an “AI agent builder” and AI-assisted app creation. Given ToolJet’s open-source nature, I was curious how their AI integration stacks up, especially since they hype “build apps with natural language in minutes” in their blog.

Building with it: I spun up ToolJet (hosted version) for a test project, a simple HR employee directory app. ToolJet’s AI appears as a sidebar where you can chat or give commands while in the builder. I typed something like: “Create an employee directory app with a table of employees (name, title, department) and a form to add a new employee.” The AI responded by creating a new application with those components. It added a table widget, pre-named “EmployeesTable,” and a form with text fields for name, title, department, plus a submit button. It also generated a little query logic: since I hadn’t connected a real data source, it created a sample data array inside a ToolJet query as placeholder data (which was clever, it meant I could see it working immediately and swap in my DB later). The new employee form was set to append its input to the table’s data on submit for demo purposes.

ToolJet’s AI also highlighted potential validation and debugging hints. In the chat it said, “I’ve created the app. Next, consider connecting this to a database or API. I can help with that too. Also, I enabled debug logs in case the form submission fails.”, It’s like it anticipated the next steps I might need. ToolJet’s marketing mentions an AI “debugger” and indeed, I saw that if an error occurred (I simulated a failure by adding a failing query), the AI could explain the error and suggest a fix. It basically reads ToolJet’s error logs and gives human-readable interpretation. This felt unique, most builders focus only on generation, but ToolJet put effort into AI-assisted debugging (their blog calls it “AI debugging” as a feature).

I later connected a Google Sheets as a data source (since that’s a common quick backend). I asked the AI to “Bind the employees table to a Google Sheet with columns Name, Title, Department”. It guided me through the OAuth setup (opening a window for me to connect the Google account) and then it generated the integration: a query that fetches rows from the sheet and populates the table, and another query that appends a new row when the form is submitted. This was pretty magical, normally, figuring out Google Sheets API and connecting in a tool takes a bit of manual reading; the AI just did it. Under the hood, it utilized ToolJet’s existing connector, but it wrote the query code (which uses ToolJet’s scripting) automatically.

Advantages: 

1. Open-source and extensible: The fact that ToolJet is open-source meant I could even self-host it and keep the AI features internal. For organizations hesitant to send data to an AI service, ToolJet offers an approach where you can configure it to use your own model or API key. I used their cloud, but knowing this flexibility is great. Also, the community can improve the AI prompts and logic since it’s open, I saw some GitHub discussions on prompt tuning. 
2. AI debugging and error handling: This is a standout. I deliberately messed up a component’s binding and got an error. The AI debugger popped up a message like, “The query to add a new employee failed because the ‘Department’ field was empty (which is not allowed). Try providing a default value or making the field required.” That context-aware help is exactly what non-expert builders need. It reduces frustration when something isn’t working, the AI essentially acts as tech support, analyzing the situation. 
3. Robust customization after generation: ToolJet’s AI uses the existing powerful features of ToolJet. After generation, I could still dive into the JavaScript editor to tweak a query, or add custom CSS. It’s not limiting me, rather, it jumpstarts and I have full control to refine. This means I could do fancier stuff (like writing a small JS transformer for data) that the AI might not handle automatically. ToolJet supports injecting code, and the AI sometimes even generated code blocks inside the platform’s scripting environment for me. 
4. Enterprise readiness (security, deployments): ToolJet being aimed at internal tools means it has role-based access, on-prem deploy, etc., similar to DronaHQ. The AI respects those, e.g., when I built the app, it was still contained in ToolJet’s usual auth framework. This is important if I’m to trust the app beyond just a demo. ToolJet also touts compliance (SOC2, GDPR) and the AI doesn’t change that equation since it works within the app builder’s framework.

Limitations: 

1. Still evolving prompt understanding: In my usage, ToolJet’s AI sometimes needed very explicit instructions. If I was too general, it either asked follow-up questions or made incorrect assumptions. For example, I first said “make an employee directory” without specifying fields, it defaulted to Name, Email, Phone. When I meant Title and Department, I had to correct it. It’s not a big deal, but to leverage it best I had to be clear and maybe build in steps: generate basic app, then enhance it with additional prompts. The UX was slightly less fluid than DronaHQ’s for initial prompting, but it’s improving. 
2. UI/design limitations: ToolJet’s design options are somewhat basic (this is true without AI as well). The AI will use the standard components, which look fine but not flashy. If you want pixel-perfect, you’ll still have to manually adjust styling or inject CSS. The AI doesn’t automatically apply a bespoke design system or fancy layout beyond what ToolJet offers. So the resulting app might look somewhat utilitarian (which is usually fine for internal tools). 
3. Performance concerns on self-host: While the cloud version was snappy for me, I’ve heard from peers that if you self-host with the AI features, you need decent server resources (especially if running an AI model locally). ToolJet’s AI might call out to OpenAI or others, so you also need to manage those API keys/costs. It’s not a plug-and-play offline solution (nor would one expect it to be). But for small teams without DevOps, setting up the AI builder might be non-trivial; using their hosted is easier and that means cloud (with your data going through them). 
4. Documentation and learning: The AI is great, but understanding what it did sometimes required looking at the queries it created. ToolJet is developer-friendly, but a pure citizen developer might be a bit lost when the AI inserts a piece of JavaScript in a query. For example, after binding to Google Sheets, I inspected the query code to ensure it was correct. Some understanding of ToolJet’s environment was helpful. They might need to improve how the AI’s actions are presented (maybe a summary of “I created X, Y, Z for you”).

Where it fits: ToolJet AI is excellent for rapid internal tool development, particularly for teams that appreciate open-source or need on-prem solutions. I see it being used by startups or SMEs who already favor ToolJet for cost reasons (free, self-hostable), the AI now lowers the skill barrier to build apps on it. It’s the kind of tool where a non-developer PM or ops person could build a decent app with a bit of AI help and maybe occasional developer input for advanced parts. The AI debugging feature also means it’s forgiving for beginners, it helps you fix issues as you go. In the dev lifecycle, ToolJet AI would cover initial development through to perhaps maintenance (imagine later saying “AI, add a column for Employee Start Date to all relevant parts”, it could do that). While I still lean on DronaHQ or Retool for enterprise scale (they have more enterprise features), ToolJet’s community-driven innovation with AI is compelling. I’ll keep an eye on how it progresses. For now, it’s a cost-effective way to get AI-assisted app building if you’re inclined to go the open-source route.  

10. Superblocks (Clark)

What it is: Superblocks is another platform in the internal tools/automation space, and Clark is what they’re calling their new AI agent. Clark’s claim to fame is being “the first AI agent to build internal enterprise apps”. The name comes up a lot in both Low-Code Builders and Autonomous Agents, because Clark spans both: it can build apps via AI and function as an AI ops agent. I got early access to Clark as part of a trial Superblocks offered after their big funding announcement.

(Detailed review coming soon)

Next, I’ll explore “Vibe Coding Tools,” which focuses on UI/UX design with AI, essentially, how AI assists in creating the look and feel (“vibe”) of an app. Bookmark this blog to visit again!