Open any productivity app or visit almost any website today, and chances are you’ll find some form of AI integrated. It might be a chatbot, a smart assistant, or a tool that helps you create workflows and prototypes in seconds. AI is everywhere.
For most people outside the tech bubble, names like ChatGPT, Gemini, or Copilot are familiar. And whether you love it or have reservations, we can agree on one thing: AI often saves time, and in business, time is money.
But here’s the real question: Can AI replace a developer?
Our perspective? Not entirely. While AI can significantly enhance productivity and streamline certain tasks, it cannot fully replace the creativity, problem-solving skills, and nuanced understanding that human developers bring to the table. Let’s explore this further from a frontend and design perspective, using a few examples and experiments we’ve tried ourselves.
Impressions of Figma Make
We recently experimented with Figma Make, and the results were incredibly impressive. With just a couple of short prompts, the tool generated designs that matched almost exactly what we had in mind, almost instantly. In a matter of minutes, we had layouts that could even be published online if needed.
Here are some of the things we tried:
- A volleyball site for a local team
- Re-creating an app we already have in production
- Building an app based on a picture mockup
Sounds amazing, right? Absolutely! While the experience was exciting, it did come with some limitations. All the apps had a somewhat similar design language, which meant there wasn’t much true creativity in the outputs. It reminded us a bit of AI-generated images: they look great from a distance, but when you zoom in, you can tell they’re AI-made.
Maybe that’s fine for you or your client, but for others, it might be a dealbreaker. However, a bigger issue was that these aren’t finished products. You’ll need to tweak them a lot to get them where you really want them. Plus, while we were lucky in some of our tests, prompting doesn’t always give you exactly what you need. Nevertheless, what Figma Make brings you is truly amazing and can definitely help you in prototyping!
The Quality of the Generated Code in Figma Make
One important note: Figma Make does not produce a design file. If your goal is to create a polished design system, this isn’t the tool. But if you’re focused on rapid prototyping, this is where Figma Make shines. It’s great for quickly exploring ideas and generating layouts, even if you’ll need an external plugin later to convert the output into a proper design file. Its strengths can really accelerate your design thinking process.
Now, about the code quality:
The generated code is… okay for quick demos, but far from production-ready. If you’re used to a specific structure in your applications or follow certain architectural patterns, you might find it frustrating. That said, it’s not useless, far from it. For example, it outputs styling with Tailwind CSS, which you can easily reuse into your own project.
The real challenge comes when integrating this code into an existing project with your own rules and constructs. That takes time. For instance, we use Next.js, and the generated code simply isn’t structured for that framework. Some pieces might fit, but overall, it lacks essentials like:
- Localization
- Layout or page components
- Server components
- API integration (you’ll need to wire that up yourself)
But on the plus side, it does set up some mock data that you can replace fairly easily.
So if you are building custom software, Figma Make’s code might not be your fit. But if you’re creating a simple static website, where the end result matters more than the internal structure, it can be a great tool. Just be prepared to experiment with a few prompt iterations to get the best output.
What About GitHub Copilot?
We began our journey with GitHub Copilot during its beta phase, and our initial impressions were a mix of awe and frustration. While it showed incredible potential, there were moments when it missed the mark, leading some of us to temporarily disable it.
Fast forward to today: Copilot has evolved significantly. It’s now more capable and, at times, impressively proactive. This proactivity can be a double-edged sword, sometimes it saves us valuable time, while other times it can feel a bit overwhelming. Fortunately, we have the option to disable some of its features to better suit our preferences.
But here’s the bigger question: Do we trust it?
Our answer: Not completely. While this might sound bold, we always double-check Copilot’s suggestions. Occasionally, its recommendations don’t fit the specific context. However, it often points us in the right direction, even if it sometimes leads us astray.
When working with AI, this is something you need to know: AI can hallucinate. If you don’t know exactly what you’re doing, you might not notice until it’s too late. One thing AI excels at is presenting its ideas with confidence, which is how it is designed. So, whether you’re coding or using it as an advanced search engine, always keep this in mind.
Why Developers Are Still Essential
Maybe we sound biased here, after all, if developers weren’t essential, many of us would be out of a job in a few years. But bias aside, the truth is this: developers are and will remain essential.
Why? Because developers bring something AI simply doesn’t:
- Context: understanding the business goals, edge cases, and user needs.
- Structure: designing maintainable, scalable codebases.
- Architecture: making decisions that impact performance, security, and long-term sustainability.
Sure, you might think, “Let’s just give AI all that context.” But even then, the output wouldn’t be nearly as efficient, maintainable, or trustworthy as what a skilled developer or team can deliver.
Will a developer-written application be bug-free? Probably not, mistakes are human. But bugs are solvable, and when a developer writes the code, it’s easier to trace and fix issues. Hand that job to AI, and you might end up with a completely different piece of code. Why? Because AI doesn’t truly understand context, it doesn’t care. It generates code based on probabilities, and if it’s wrong, it won’t know until you tell it is wrong.
So, should developers stop using AI? Absolutely not. Use it as:
- An advanced autocomplete tool
- A rubber duck for brainstorming
- A partner for pair programming
- A helper for small tasks and repetitive work
- A way to speed up documentation
But here’s the golden rule: never blindly trust it. Always verify, because AI can be wrong, and when it is, the cost of fixing mistakes can be high. But is it really AI’s fault? Not always. If the internet contains wrong information and AI is trained on it, who’s to blame?
People lie; AI doesn’t. It just doesn’t know, it lacks awareness.
Conclusion: Developers + AI, Not Developers vs AI
AI is everywere right now, maybe even a little overhyped, but it’s here to stay. And as developers, yes, we should absolutely use it. Not to write all our code, but as an assistant: a tireless junior dev who never sleeps, always ready to look things up and spark ideas when we’re stuck.
Yes, AI can be wrong. It makes mistakes, so do humans. The difference? AI is insanely fast at generating code snippets, boilerplate, and documentation. It might lack true creativity and deep understanding, but that’s where we as developers come in. We know the context, the goals, and the customer. AI doesn’t.
So, leverage AI to stay ahead, even if you’re skeptical. Use it to speed up repetitive tasks, brainstorm solutions, and boost productivity. But always keep control. The future of coding shouldn’t be developer vs AI, it should be developer with AI.
Photo by Possessed Photography on Unsplash
Abonneer je op onze RSS feed