Eleven Ventures and Corallia Ventures Back Bitloops’ AI-Powered Frontend Revolution

• Bitloops’ AI copilot converts Figma designs into high-quality, production-ready frontend code and raises EUR 1M from Eleven Ventures and Corallia Ventures
• The platform addresses frontend development bottlenecks and repetitive tasks by utilizing advanced AI and structured workflows, ensuring clean, maintainable, and scalable code
• The mission is to elevate developer and designer roles, making teams more efficient and collaborative

This May, the well-known Bulgarian VC fund Eleven Ventures (invested in Outfindo, among others) co-led the Pre-Seed round of the Greek-Cypriot AI startup Bitloops that develops a copilot for turning Figma designs into ready-to-use code. The round was joined by the Greek Corallia Ventures and amounted EUR 1M.

Introducing the Founders

Vasilis Danias, Bitloops’ CEO and CTO, is a seasoned fullstack engineer with a BEng in AI & Software Engineering and an MBA from HEC Paris. He began his career at Accenture and went on to lead product and tech initiatives at UBS and Uber, where he worked across various markets. At BEAT (now part of FREENOW), he led a 50-person cross-functional team spanning engineering, product, and operations. Mr Danias studied and worked with AI before it became mainstream—gaining a grounded understanding of both its transformative potential and its limitations. His interest always revolved around scaling engineering output—how to build faster, with less friction, without compromising quality.

Bitloops’ COO and CMO Sergio Pereira brings strong strategic and operational experience. He holds an MEng from Imperial College and an MBA from INSEAD. He began his career as an engineer at Toyota before transitioning into strategy consulting with Roland Berger and BCG. Later, he founded and scaled two startups—including ComparaJá, a financial product comparison platform. His success there led to him being headhunted to launch FREENOW in Portugal, where he served as GM and built the local operation from scratch.

Identifying the Frontend Bottleneck

The co-founders met when they were leading operations in Greece and Portugal at FREENOW. Both these markets were seen as growing, profitable, and full of potential, but when it came to building new features or improving the product for local users, the two consistently ran into a wall: too expensive, too complex, too low on the global priority list. Even small UI changes had to wait behind requests from Germany or the UK. The bottleneck wasn’t vision or user insight—it was engineering bandwidth and the cost of delivery.

In these roles, they saw how often product ambition got constrained by frontend delivery bottlenecks—especially in fast-moving, resource-constrained environments. As such, the idea behind Bitloops was born from the frustration of trying to ship meaningful product improvements in markets that were always considered ‘too small.’ The two lived every layer of the problem—from writing code and managing engineering teams to launching products and fighting for roadmap priority, and Bitloops is the product of years of shared pain and the conviction that teams everywhere should be able to ship beautiful, scalable frontend code—without needing an army of engineers to do it.

Frontend Focus

Bitloops’ story begins back in 2021 when the founding duo began tackling backend workflow orchestration. The early vision was to encode architectural best practices, such as DDD (domain-driven design), CQRS (command query responsibility segregation), event sourcing—into a framework that could help engineers build scalable, maintainable systems faster. This foundation provided for an essential in-depth understanding of software structure, modularity, and automation.

Taking on more consulting projects to fund development and stay close to real-world teams,we noticed a recurring friction point: frontend development. More specifically, the amount of manual effort required to convert UI designs into usable, scalable frontend code wasn’t just tedious—it was error-prone, expensive, and a drag on time-to-market.

‘That’s when we shifted our focus. In late 2023, we began working on automating the design-to-code process. We weren’t starting from scratch—we had years of experience building automation tools and a clear philosophy around developer-first design. But this shift required new thinking: how do you replicate the judgment of a senior engineer when analyzing a design file? How do you ensure the output is actually usable in production, not just a demo?’ Mr Pereira recalls.

‘We find the team’s technical depth, clear product vision, and the early traction from developer communities particularly impressive. Their approach is not only innovative but also deeply rooted in solving real pain points that engineers face daily. As AI reshapes software creation, Bitloops is uniquely placed to lead this transformation for professional-grade applications,’ Eleven Ventures’ partner Svetozar Georgiev shares.

The Professional Copilot

The answer emerged as Bitloops as it’s known today—a frontend copilot built for professionals, focused on quality, structure, and flexibility. It updates frontend development with a combination of advanced AI and professional workflows. Unlike low-code tools, it comprehends layout logic, design systems, and developer conventions, allowing teams to create precise, high-quality UI components directly from designs.

Acting like a senior engineer, this copilot interprets layouts and adheres to design systems, producing clean, reusable, and fully responsive production-ready code. Bitloops addresses key challenges such as managing CSS at scale, maintaining design consistency, and reducing rework. It automates design system updates, generates Storybook documentation, and produces scalable code, freeing engineering teams from repetitive tasks and significantly accelerating delivery.

AI-Assisted Code Generation Beyond Generic LLMs

The core parts of Bitloops’ AI-driven code generation engine were built in-house. The team developed the architecture, orchestration logic, and decision layers that make the output usable in professional settings.

‘That said, we do make use of leading existing models—including OpenAI, Claude, and Gemini—where it makes sense. These models are powerful, but on their own they aren’t enough to produce clean, scalable code that teams can ship. From the beginning, we knew that creating production-grade frontend code wasn’t just about throwing designs at a generic LLM and hoping for the best. The code needs to be readable, maintainable, reusable—and that means the system generating it has to understand structure, not just syntax,’ Mr Danias tells ITKeyMedia.

Bitloops’ approach is to treat AI as a collaborator within a larger, orchestrated workflow. The platform is built around a modular engine that breaks down the design-to-code process into granular steps. These steps either rely on deterministic logic, or require more context-aware reasoning, where AI comes in. Such an orchestration layer—how and when different models are utilized—is what makes Bitloops stand out.

An internal experimentation platform, ‘XP’, was built to test different models, prompts, and configurations side-by-side, continuously refine the use of AI, optimize cost and performance, and maintain full control over the output.

‘The key insight is this: AI on its own doesn’t know enough about software engineering to be trusted with production code. But when paired with the right architecture, prompts, and checks, it becomes a powerful tool for accelerating what great developers already do,’ Mr Danias explains.

Building Trust by Demonstrating Quality

‘AI-generated code’ does raise justified skepticism, especially from experienced engineers. There have been many tools that promised clean code but delivered something that’s unreadable, unmaintainable, or was breaking once touched. That’s why Bitloops made it its core product philosophy to make the generated code look and feel like the work of a senior developer. While Bitloops uses AI, it cannot be called ‘AI-generated code’ in the loose sense. It’s more like structured, engineered output produced by a system designed to match the way professional teams actually build software.

‘When we talk to the developer community, we don’t just list benefits—we show them. We share side-by-side examples, we open up the output for inspection, and we encourage devs to bring their own designs and see how Bitloops handles them. We’ve designed the product to be fully inspectable: no black box, no hidden magic. You get clean, modular, framework-consistent code you can actually use in production—and you can trace back how it was generated, tweak it, or integrate it however you like,’ Mr Pereira states.

The Bitloops platform already had a closed alpha launch, onboarded over 100 developers, and collaborated with five design partners. Reportedly, one of the most consistent pieces of feedback is ‘this code I’d actually ship.’ Such feedback validates Bitloops’ high code quality and developer experience, proving its effectiveness where pre-existing solutions fell short.

In terms of market education, Bitloops is heavy on practical content—walkthroughs, plugins, live demos, and eventually open design/code libraries illustrating how the solution performs across real-world projects.

‘We’re speaking directly to the engineering pain points: time-to-market, onboarding new developers, avoiding technical debt, and scaling design systems. We don’t replace developers but remove the repetitive grunt work that gets in their way,’ Mr Pereira adds.

The ultimate message to developers is to trust their own judgment: try the AI-assisted code, read it, run it, and see how much further you can go when you’re not starting from zero.

Technical Hurdles in Code Generation and Overcoming Them

As Bitloops grows, various potential technical or operational challenges are to be anticipated in consistently maintaining high quality of the generated code across diverse design systems. After all, in the real world, no two design files are alike, they vary in structure, naming conventions, component granularity, responsiveness logic, and adherence to design systems (or lack thereof). This variability introduces complexity at every layer of code generation.

The co-founders elaborate:

• The first technical challenge is interpretation: how do we understand what a design is trying to express, even if it’s not structured “correctly”? We’ve built a system that doesn’t rely on rigid assumptions. Instead, it remaps and restructures each design into a coherent internal model using a combination of deterministic logic and AI-based inference. But ensuring that interpretation works across edge cases, incomplete designs, or poorly named layers is an ongoing challenge—and one we’re tackling head-on with continuous training and feedback from design partners.
• The second challenge is consistency at scale. As we support more frameworks, plugins, design styles, and company-specific conventions, maintaining a coherent output format becomes exponentially more complex. Our strategy here is modularity: breaking the generation pipeline into tightly scoped steps that can be independently validated, tested, and improved. We’ve also invested early in tools like our XP platform that allow us to benchmark and regress output quality with every change.

It is apparent that the bar will only rise in the future. That’s why it becomes essential for Bitloops to hire key technical roles—especially in graph neural networks and AI—to help generalize across design patterns more effectively.

‘We’re also exploring ways to encourage users to ‘teach’ Bitloops their own design system through examples and context, so the output becomes increasingly personalized and adaptive over time. Overall, we believe the best way to maintain quality is to stay close to our users. Every design converted is a chance to learn, and we’re building the feedback loops—both automated and human—that ensure Bitloops keeps getting better the more it’s used,’ Mr Danias states.

Further Platform Integration

Speaking of the variety of designs, Figma currently remains the Bitloops platform’s primary input source. The Bitloops system is optimized to interpret Figma files with a high degree of flexibility (even when they don’t follow strict naming conventions or design system rules).

‘We see a strong alignment in vision: Figma has done an exceptional job democratizing design, and Bitloops is working to bridge the next gap—getting from design to scalable, production-quality code,’ Mr Danias comments.

The team is actively working on a Figma plugin to make Bitloops even more accessible within existing workflows. This will allow designers and developers to trigger and customize code generation directly from within Figma, reducing friction and making the feedback loop tighter and more collaborative.

The co-founders assure that beyond Figma, Bitloops is built to be design-source agnostic. The pipeline is structured in a way that it could support other tools like Adobe XD, Sketch, or even newer options over time. The core idea is to interpret intent, not just pixels or layers, so as long as the design tool can convey structural meaning, Bitloops support it.

The startup also has a pronounced interest in longer-term partnerships—not just with design platforms but also with frontend frameworks, cloud hosting providers, and dev toolchains. The team’s broad vision is to make Bitloops a fully integrated copilot across the entire frontend development lifecycle.

Future Growth and Roadmap

In this regard, the new round of funding marks Bitloops’ next phase of growth on strong footing—backed by product validation, and a clearly defined roadmap. Namely, the raised capital will accelerate both product development and team expansion, aligned with the founding team’s long-term vision of making Bitloops the go-to frontend copilot for professional engineering teams.

The roadmap includes:

• Developer-Centric Features: Adding intelligent handling of component variants, better viewport-specific rendering, and deeper integration with design systems—to fit seamlessly into real dev workflows.
• System Integrations: Expanding beyond Figma to support more design tools, CMS platforms, and frontend frameworks—giving teams flexibility across their tech stack.
• Model Refinement: Fine-tuning proprietary AI models to handle high-impact, code-structural tasks with even greater precision.
• Team Growth: New hires in AI, product, and developer relations to scale both product and community.
• Domain-Specific Language Model (DSLM): Continuing to advance in-house AI models, specifically trained on frontend patterns, to ensure generating the kind of code that the co-founders originally intended.

For Corallia Ventures’ partner Dr Nikos Vogiatzis, Bitloops is a great case of industry-led technology transfer, transforming real-world, applied know-how into an innovative commercial solution with global potential, which is exactly the kind of founder-led innovation that his fund looks to support.

Success Beyond Immediate Momentum

Overall, this next chapter is about building daily value for thousands of frontend teams—and building the infrastructure to scale it globally. Bitloops measures its success by evident proof of the platform becoming indispensable to frontend teams. Look ahead to future funding rounds, the entrepreneurs list critical indicators that reveal how their startup is solving a real problem, at scale:

• Repeat Use. The platform is designed to be part of a developer’s daily workflow. Seeing users come back consistently, across different stages of a project, is the clearest signal of product-market fit.
• Time-to-Value. The platform tracks how quickly new users can convert a design into usable, clean code and feel confident deploying it. The faster such value realization happens, the more accustomed to Bitloops these users grow.
• Conversion & Monetization. As Bitloops’ freemium model gains traction, it will be possible to measure activation rates, paid conversion, and average spend per team. Strong conversion from free to paid version will validate both the user interest and the platform’s dependability.
• User Expansion. It is also necessary to track how individual users grow into teams—how a single developer trialing Bitloops can introduce it to their org, leading to wider adoption. This ‘land and expand’ dynamic is crucial to scaling efficiently.
• Community and Ecosystem Engagement. We want to see developers talking about Bitloops in public—sharing snippets, requesting integrations, contributing feedback. That kind of pull tells us we’re not just solving a need, but starting to define a new category.

‘Ultimately, we’re building for longevity, not just momentum. If Bitloops becomes the tool developers instinctively reach for when they get a Figma file, the long-term metrics—LTV, retention, ARR—will follow. But the leading indicators are all about depth of use and developer trust,’ Mr Pereira says.

Rebalancing Developers and Designers Work

To conclude, the global shortage of skilled software developers isn’t just about headcount—it’s about time, attention, and the kind of work developers are asked to do. Often, highly trained engineers spend their days on repetitive, low-leverage tasks like converting UI designs into code, tweaking layout responsiveness, or maintaining style consistency. Such a talent gap should be called more precisely a misallocation of talent.

Bitloops addresses this directly, automating the 70–90% of repetitive, predictable, and time-consuming frontend work, so developers can focus on the remaining 10–30%: building logic, crafting user flows, optimizing performance, or integrating systems. This kind of leverage helps existing teams move faster and broadens the capacity of smaller and non-VC-backed companies to deliver high-quality digital experiences without having to expand frontend teams. A solution like Bitloops’ becomes a force multiplier, making great developers more productive, and it gives lean teams the power to ship at a level they couldn’t otherwise afford.

‘In more technical terms, the design-to-code sector represents a USD 12B market, with nearly half powered by React—the framework behind roughly 40% of modern web apps. Despite surging demand, frontend development still faces a talent crunch. Projections indicate a shortage of over one million developers by 2027. Emerging AI tools have fallen short, delivering snippets, not scalable solutions. Bitloops bridges that gap with a robust, structured, and maintainable approach to code generation,’ Dr Vogiatzis continues.

A Collaborative Future for Elevated Engineering Teams

To reiterate, Bitloops is about elevating developers’ and designers’ roles by removing the grind.

Frontend developers can shift from manual implementation to system orchestration. Instead of spending hours on layout scaffolding, CSS fixes, and design fidelity tweaks, they can focus on integrating business logic, refining user flows, and architecting scalable component systems. While Bitloops handles the tedious parts, developers stay in control, but gain back time and mental space to solve higher-order problems.

As for designers, the handoff wall starts to come down. With Bitloops, their designs no longer just represent ideas—they become executable. This creates a tighter, more iterative feedback loop between design and implementation. Designers can see their work go live much faster, test responsiveness or component behavior earlier, and have more influence over how final products take shape.

‘That’s what got Eleven Ventures drawn to Bitloops—they are building a category-defining product at the intersection of AI and professional software development, addressing a fundamental challenge: the tradeoff between speed and quality. Their vision—enabling developers to build faster without compromising on maintainability or performance—aligns perfectly with where the industry is headed and directly with one of our core focus areas: the Future of Work and AI,’ Mr Georgiev concludes.

In the long run, the way engineering teams operate is prone to being rebalanced. Reduced need for manual frontend scaffolding makes room for more strategic engineering roles, creating new opportunities for designers, PMs, and hybrid contributors to participate meaningfully in product delivery, without compromising on code quality. In other words, teams can use the talent they already have more effectively, efficiently, and creatively.

All team roles become more collaborative and less siloed. Instead of friction over handoffs and lost context, there’s shared ownership over product delivery, with automation handling the boilerplate and humans focusing on craft. The best teams won’t be the ones with the most engineers—they’ll be the ones who use their engineers most intelligently.