From Copilot Loops to No-Code Magic: My Journey Building Illico.be
Sometimes the best lessons come from projects that humble you. Meet Illico.be, my side project for organizing board game nights with friends and family. What started as a simple playground to experiment with AI coding tools became a fascinating journey through the current state of development workflows – complete with unexpected detours and surprising discoveries.
The Setup: A Perfect AI Coding Playground
I wanted to build something real but manageable – a board game organizer seemed perfect. Not too complex, actual utility for my gaming group, and a great excuse to dive into the AI-assisted development everyone’s been talking about.
The static website part went smoothly. GitHub Pages, Astro, VSCode with GitHub Copilot Pro – exactly what you’d expect from modern “vibe coding.” I found myself describing what I wanted in comments and watching Copilot fill in the blanks. It felt magical, like having a junior developer who never got tired and had memorized every Stack Overflow answer.
But then I got ambitious.
The Reality Check: When AI Becomes Your Debugging Partner
For the actual app, I designed a proper architecture: monorepo, microservices, TypeScript everywhere, React frontend, NestJS backend, GraphQL API, Sequelize 7 for the database. Everything a senior developer would spec for a scalable application.
GitHub Copilot started strong. It knew the patterns, suggested reasonable implementations, and even caught some of my typical mistakes. But as the codebase grew more complex, something shifted.
The AI began having conversations with itself.
I’d write a comment asking for a function, Copilot would suggest implementation A, then immediately suggest a “better” implementation B that contradicted A. Then it would hallucinate dependencies that didn’t exist, reference APIs with slightly wrong method signatures, and create circular logic loops that looked almost correct at first glance.
The problem wasn’t that Copilot was wrong – it’s that it was almost right, consistently. Close enough to pass a quick review, wrong enough to cause runtime errors. I found myself spending more time debugging AI suggestions than I would have writing the code myself.
This is what the research calls the “productivity paradox” – developers feel faster while actually moving slower, because the cognitive load shifts from creation to validation.
The Pivot: Sometimes Less Code is More Code
After hitting too many Copilot loops, I decided to try something different. A friend had mentioned Lovable, one of these new AI-powered no-code platforms. It seemed expensive and honestly, a bit “too good to be true” for my senior developer sensibilities.
But I was curious. How far could these platforms really go?
Two hours later, I had a working prototype.
Not a mockup. Not a static demo. A real application with user authentication, database operations, game scheduling, and friend invitations. Under the hood, Lovable was using Supabase for the backend – PostgreSQL, real-time subscriptions, row-level security. Proper architecture, just assembled through natural language descriptions instead of thousands of lines of custom code.
The experience was oddly liberating. Instead of debugging type definitions and wrestling with ORM configurations, I was describing user flows and watching them materialize. “Users should be able to create game nights and invite friends via email” became a functioning feature in minutes, not hours.
The Hidden Costs: What They Don’t Tell You in the Demos
Before you think this is a no-code evangelism post, let me be clear about the trade-offs. Every rapid development approach has costs that only become apparent when you try to scale or customize beyond the happy path.
With AI-assisted coding, the hidden cost is verification overhead. You become an AI babysitter, constantly checking that the generated code actually does what it claims. Security vulnerabilities increase dramatically – studies show 10x more security issues in AI-generated code. You’re trading writing time for review time, which isn’t always a good deal.
With no-code platforms, you’re trading speed for flexibility. Lovable generates exportable React code, which is brilliant, but you’re still constrained by the platform’s architectural decisions. Need a custom authentication flow? Want to optimize database queries? You’ll hit walls that require either workarounds or migration to traditional development.
The real challenge isn’t choosing between these approaches – it’s knowing when each makes sense and planning for the inevitable transitions.
The Senior Developer’s Dilemma: When to Use What
Here’s what I learned building Illico.be: the best approach depends entirely on what you’re trying to accomplish and when.
For the static website (marketing, landing pages, documentation), AI-assisted coding with Copilot hit the sweet spot. Known patterns, clear requirements, low complexity. The AI suggestions were helpful and the verification overhead was minimal.
For rapid prototyping and validation (the core app MVP), no-code platforms like Lovable were surprisingly powerful. I could test product-market fit and validate user workflows without getting bogged down in infrastructure decisions. Perfect for answering “Do people actually want this?”
For production systems (when Illico.be grows beyond MVP), I’ll likely need traditional development approaches. Complex business logic, performance optimization, custom integrations – these still require the kind of deep technical control that neither AI assistants nor no-code platforms fully provide.
The Path Forward: Hybrid is the New Normal
The most interesting insight from this project wasn’t about any single tool – it was about workflow flexibility. Modern development increasingly means choosing the right tool for each phase of the project lifecycle.
Start with no-code for rapid validation. Move to AI-assisted development for production features where you need more control but want to accelerate delivery. Fall back to traditional coding for performance-critical components or novel algorithmic work.
This hybrid approach requires a different kind of technical leadership. Instead of deep expertise in a single stack, you need broad familiarity with multiple development paradigms and good judgment about when to use each.
Lessons Learned: The Practical Takeaways
If you’re considering similar experiments, here’s what I wish I’d known:
Set clear success criteria upfront. Define what “good enough” looks like for each project phase. MVP validation has different quality requirements than production systems.
Plan for migration paths. Choose tools that don’t lock you into dead ends. Code export capabilities, standard databases, and familiar architectures matter when you need to scale or customize.
Invest in verification processes. Whether you’re reviewing AI-generated code or testing no-code platform outputs, you need systematic ways to catch issues before they reach users.
Embrace the learning curve. Each approach has its own best practices and gotchas. Budget time for experimentation and skill development, not just feature delivery.
The Bottom Line
Illico.be taught me that the future of development isn’t about replacing our existing skills – it’s about expanding our toolkit. AI-assisted coding and no-code platforms are powerful tools, but they’re still tools. They amplify good engineering judgment and enable rapid iteration, but they don’t eliminate the need for technical thinking.
The real opportunity is in becoming fluent across multiple development approaches and knowing when each delivers the best results. Sometimes that means grinding through complex TypeScript configurations. Sometimes it means describing your requirements in plain English and watching them become reality.
The key is maintaining engineering rigor while embracing new possibilities. Build fast, but understand what you’re building. Prototype rapidly, but plan for production. Leverage AI and no-code tools, but keep your debugging skills sharp.
After all, someone still needs to understand how it all works – and that someone is still us.
Illico.be is live and helping my board game group stay organized. The MVP was built in under two hours with Lovable, proving that sometimes the best way forward is the one that gets you there fastest. You can follow the project’s evolution at illico.be.