AI Development Tools in 2024
A Practitioner's Journey Through Automation, Agents, and Web Apps
I've spent 2024 quite a bit of time exploring AI coding assistants and no-code/low-code tools like Make.com, Lovable, and Cursor. With a mixed background of business and technical skills (think mediocre Python and decade-old web development courses), I want to share my journey of how these tools have transformed my ability to build digital products—making the process faster, smarter, and more accessible than ever before.
The Year Everything Changed
2024 has been the year when coding assistants truly came into their own. While GitHub Copilot had been around since 2021, it wasn't until after ChatGPT that we saw an explosion of tools promising to automate development work. The year kicked off with Devin's launch in March (Cognition Labs announcement) - an AI developer that could build simple apps from prompts alone. After the impressive demo video and hefty $500/month price tag, the reviews have been quite negative, but it signaled a trend.
A New Way to Think About Development Tools
Traditionally, AI development tools came from two camps: Coding Assistants (like GitHub Copilot) that augment developers' capabilities, and No-Code/Low-Code platforms that focus on automation and visual programming. While Coding Assistants emerged from the software development world to support programmers, and No-Code tools evolved from business process automation, I've noticed they're converging toward the same goal: increasing development productivity.
Important: Development productivity, not developer productivity – because what matters is what gets built, not who builds it. I think, this traditional separation is becoming less relevant as the lines between visual programming, natural language interfaces, and traditional coding continue to blur.
Instead, I propose thinking about these tools based on their scope: “General Purpose” versus “Special Purpose”. General Purpose tools let you build whatever you can imagine, whether through code, natural language, or visual interfaces. Special Purpose tools excel at creating specific types of applications – whether that's a website, a workflow, or an AI agent.
During the year, I tried the below tools. They are by no means a complete overview and I used some tools at the beginning of the year - so it is also sometimes an unfair comparison.
General Purpose Tools
The first half of the year was a strong collaboration with ChatGPT. In June, I tested my web-dev skills by trying to build an AI Journalist Toolbox (documented here). This experience was both enlightening and challenging. While ChatGPT proved remarkably capable at generating functional code, I quickly learned that successful development required more than just asking for code snippets. I had to force myself to think iteratively and maintain a clear structure for the project myself.
The real challenges emerged during deployment. Wrestling with containerization, dealing with Cross-Origin Resource Sharing (CORS) issues, and implementing proper authentication felt like navigating uncharted waters. ChatGPT could generate the code, but understanding whether the solutions were secure and followed best practices required constant vigilance. The code style, while functional, often lacked consistency and could become messy easily. I found myself spending considerable time copying code back and forth between my editor and ChatGPT, highlighting the need for better integration tools.
Despite these challenges, the experience was incredibly empowering. It showed me that with the right approach and careful attention to structure, even someone with modest coding experience could build complex applications. However, it also highlighted the gap between generating code and creating production-ready applications – a gap that newer tools would later help bridge.
After my experiences with ChatGPT, I explored Claude, and found some fascinating differences in how it approached development tasks. While it's challenging to make definitive comparisons (and the models are in a constant race of improvement according to platforms like Chatbot Arena), I subjectively found Claude's code generation capabilities slightly better. What sets Claude apart is its artifacts functionality – it allows you to render JavaScript and React components in real-time within the chat interface.
While I mainly used GitHub Copilot for autocomplete and refactoring early in the year, I found it useful, but not really game-changing. It would sometimes finish a line or write a text, but not much more. However, Copilot has evolved significantly throughout the year, recently launching a free tier (announcement). It might be worth revisiting given its expanded feature set.
The real game-changer, however, was Cursor (cursor.com). Built as a sophisticated fork of Visual Studio Code, Cursor fundamentally transformed my development workflow through two core capabilities: intelligent code completion and natural language code generation.
The standout feature, aptly named "Composer," feels almost magical in practice – you describe what you want to build in plain English, and Cursor not only generates the code but understands how to modify all the necessary files in your project.
The tech behind it is pretty fascinating. The Cursor team did a great interview with Lex Fridman (even though he has a few weird political affiliations) where they got into the nuts and bolts of how they made it so fast – they've done some clever things with caching, shrinking down larger AI models, and creating smart algorithms that understand code changes instantly. This means you're not sitting around waiting for responses; it feels as quick as typing the code yourself.
I've used Cursor for both starting new projects from scratch and working on existing ones, and it's been a game-changer for both. It's like having a super-powered development assistant who can either help you lay the foundation for a new project or jump right into your existing codebase and understand what's going on. But – and this is important – I did hit some limitations as my projects got bigger. While Cursor is brilliant at writing individual features and functions, it's not great at making high-level architectural decisions. I ended up with some duplicate code and messy module structures when I wasn't careful.
Special Purpose Tools
Web Development
For web development, I discovered some fantastic specialized tools. v0 (v0.dev) generates sophisticated frontends that can be edited with Cursor to add backend connectivity. The front-ends are quite nice, but the experience was a bit messy. Almost everytime v0 used a different JS Framework (what do I know) and editing it with cursor was not always frictionless.
Bolt.new (bolt.new) offers an incredibly simple interface with one-click deployment and Supabase integration. The simplicity of Bolt.new is both its strength and limitation. While it excels at getting applications up and running quickly – literally with one click deployment – I found the development experience could sometimes feel a bit chaotic. It's like having an enthusiastic assistant who's great at getting things done quickly but might occasionally organize things in unexpected ways. This became particularly apparent when trying to maintain consistent patterns across larger applications.
Then I discovered Lovable (lovable.dev), and it felt like finding the missing piece of the puzzle. Created by the team behind gpt-engineer in Stockholm, Lovable takes a notably different approach to AI-assisted development. Instead of trying to do everything at once, it guides you through an iterative development process that feels more natural and controlled.
To give you a concrete example, I used Lovable to build a platform for creating local history tours (Stroll Storyteller). The platform encouraged me to break down the project into logical steps: first establishing the core user interface, then adding the functionality step-by-step.
Like Bolt.new, it offers Supabase integration and one-click deployment, but it adds a layer of structured development that helps prevent the chaos that can sometimes arise in AI-assisted projects.
Workflow Automation
Sometimes your goal isn't to build a full application, but rather to automate specific workflows.
I started the year with Flowise (flowiseai.com), which essentially provides a visual interface for LangChain – a popular framework for building AI applications. Think of it as a drag-and-drop interface for creating enhanced language models, assistants, and complex workflows. What particularly drew me to Flowise was its deployment flexibility; you can run it on your own hardware, which not only reduces costs but also gives you full control over your data. However, I found myself wrestling with LangChain's concepts, which, while powerful, aren't always intuitive even with a visual interface.
This led me to explore Airops (app.airops.com), which takes a similar visual approach but with a more streamlined interface. While Airops makes it incredibly easy to build basic chatbots, I found its customization options somewhat limited. It's like having a well-designed tool that does a few things really well but doesn't let you color outside the lines.
The real surprise in my automation journey came from Make (make.com), a tool that isn't primarily focused on AI. What Make lacks in AI-specific features (you won't be building RAG systems or complex agents here), it makes up for in reliability and mature functionality. Its visual interface feels natural, and the platform offers an impressive array of connectors to different services.
I put this to the test by building several tools for our news organization, with the standout project being a sales support system. This tool automatically researches potential clients by analyzing their websites, news articles, and Facebook posts to generate tailored business ideas. The only limitation I encountered was the inability to add custom Python code, but the platform's extensive built-in functions usually provided workable alternatives.
Agents
One of the most hyped concepts in AI this year has been autonomous agents – systems that can independently determine how to achieve goals rather than simply responding to specific prompts. It's a shift from telling an AI exactly what to do to simply stating what you want to achieve and letting the AI figure out the steps.
My first meaningful encounter with this concept was through Relevance.ai. What makes this platform interesting is how it combines workflow automation with autonomous decision-making. You can create various workflows (similar to Flowise or Airops), but instead of manually choosing which workflow to use, you can embed them in a chatbot that automatically selects the most appropriate one based on the user's request. The chatbot can also draw from knowledge bases or follow rule sets. While I loved this concept of giving a chatbot multiple "skills" and letting it choose the best one for each situation, the platform showed its early-stage nature with some stability issues and limitations in handling German embedding models.
Microsoft's AutoGen Studio (microsoft.github.io/autogen/0.2/) takes the agent concept in a fascinating direction by enabling multi-agent conversations. Imagine creating a panel of AI experts, each with different specialties, and having them collaborate to solve problems. I experimented with this by building an internal AI advisory board, where different agents could contribute their perspectives to strategic discussions. While AutoGen Studio's interface is still quite basic with limited functionality, it offers a glimpse into a future where AI agents might collaborate just as human teams do.
Looking Forward
This year has dramatically improved my development capabilities. I can now build and deploy web apps with simple backends much faster than before.
Especially these three tools will stick with me:
Make.com (workflow automation)
Lovable (Web-Apps)
Cursor (General Purpose)
Tools like Bolt.new and Lovable are addressing early concerns about security and reliability through integrated backends-as-a-service and automated deployments.
The main limitation remains handling complexity - AI models still struggle with upfront architecture planning. However, for straightforward applications and automation tasks, these tools have made development significantly more accessible to people like me who straddle the business-technical divide.
Looking at the tools I've discussed, they can be classified along two key dimensions that reveal their fundamental approaches. The first dimension considers who guides the development process: at one end, we have user-driven tools where developers maintain precise control over each decision, while at the other end, autonomous tools independently determine their course of action. The second dimension focuses on the development environment itself: integrated tools work within familiar development environments like IDEs, while isolated tools operate in their own specialized platforms. This classification helps us understand where each approach might thrive.
For instance, when building systems with stringent requirements for security, scalability, and architectural complexity – think banking systems or critical infrastructure – integrated, user-driven tools prove most valuable by allowing developers to maintain careful oversight while leveraging AI assistance. Meanwhile, autonomous tools show tremendous promise for rapid development and innovation, though a crucial challenge remains: finding ways to harness their capabilities within more controlled development environments without sacrificing their speed and creativity. This balance between autonomy and control will likely shape the next evolution of AI development tools.