AI-Assisted Product Engineering: Lessons from a 30-Day Bitcoin Yield Platform Build

At Cheesecake Labs, we aimed to push the limits of AI in developing real, production-level products.

The idea was simple: hand over a complete project brief and brand guide to an autonomous AI and see if it could build and deploy a working lead capture platform for Bitcoin and Cardano yield opportunities within 30 days.

This included everything: frontend, backend, blockchain integrations, and secure data handling.

The results were surprising — not only in speed, but also in how capable and “aware” the AI proved to be during the process. The project ran for 22 days, from October 16th to November 7th, but within just 48 hours, it had already developed its main features and a functional frontend.

From brief to prototype in two days

The project started with two documents:

• A Project Brief describing the “Stake-to-Waitlist” campaign and the lead capture flow.
• A Brand Guidelines document outlining tone, typography, and color identity.

We collaborated closely with Lovable AI across a 48-hour sprint — iterating, validating, and refining until a complete, functional prototype was delivered:

• A responsive landing page consistent with the brand.
• A Supabase backend with Row-Level Security (RLS).
• Functional Cardano wallet integrations (Lace and Eternl).

It was able to interpret business intent and design direction directly from PDFs—something that normally requires multiple handoff cycles between design and development.

How Lovable understands and adjusts design

One of the most interesting findings was how well Lovable understands design structure and context.

With only a few instructions, it could make accurate corrections to layout alignment, spacing, and color consistency — reflecting the same alignment, spacing, and visual consistency decisions usually handled during front-end implementation.

When the layout didn’t perfectly match the Figma reference, simply describing the issue (“the call-to-action feels too close to the footer” or “the hero section needs better visual balance”) was enough for Lovable to fix positioning, adjust paddings, or recolor components in seconds.

It behaves less like a static code generator and more like an interactive teammate with a visual sense of the product.

Intelligent input handling

Another positive surprise was how Lovable handles uncertainty. When given complex or partially ambiguous instructions, it doesn’t rush to change code blindly. It asks clarifying questions, similar to a chat interface.

This happened multiple times when we introduced compound prompts involving both design and logic, and the tool paused for clarification rather than making unsafe assumptions.

This behavior makes collaboration with the AI feel much closer to working with a junior engineer who checks understanding before proceeding.

Read more: How to Integrate AI Into an App

The security review system and a real vulnerability fix

Lovable includes a built-in security review area that flags warnings and possible vulnerabilities during development.

It doesn’t just highlight problems. You can also ask it to fix them directly from that view. A notable example came up early in the project:

The landing page included a form that collected the user’s name and email, but the Supabase queries were initially public.

This meant that even though no authentication system was in place, the collected data could technically be accessed externally.

Using the security review system, we worked with Lovable to redesign the flow so that only Edge Functions could access the database, and submissions were only accepted after wallet validation through cryptographic signatures.

Lovable handled the creation of the validation logic itself, ensuring that every commitment stored had a verifiable wallet signature.

The fix worked seamlessly and became one of the strongest security aspects of the project.

Technology stack and architecture

Frontend

• React 18 + Vite + TypeScript
• Tailwind CSS with semantic tokens derived from brand colors
• Radix UI and shadcn/ui for accessible, reusable UI components

Backend

• Supabase with Edge Functions (Deno)
• PostgreSQL database using Row-Level Security
• Secure endpoint for storing commitments validated by wallet signatures

Blockchain integrations

• Modular provider architecture for Cardano, Bitcoin, and hardware wallets
• Factory and Hook patterns for connecting, signing, and balance fetching
• Unified API for all wallet types

Lovable also generated a detailed technical overview documenting the architecture, database schema, and security measures.

Refining and structuring code with Cursor

We connected a dedicated GitHub repository directly to Lovable for code synchronization and version control.

Initially, Lovable grouped all blockchain logic into three large hooks — one each for Bitcoin, Cardano, and hardware wallets. The implementation was solid but lacked modularity and readability.

Using Cursor, we reorganized these into separate modules per wallet provider, improving structure, reusability, and consistency.

The refactor was committed through a pull request, bringing back human engineering discipline into the AI-generated foundation.

This showed how AI can accelerate initial delivery, while experienced developers refine the architecture for long-term maintainability.

Read more: Beyond “Vibe Coding”: Engineering with AI and Cursor

Low-code power, but with trade-offs

Lovable’s low-code model is powerful, but not without limitations.

For complex or large projects, experienced developers may find it restrictive in certain aspects:

• Large, repetitive files: The AI sometimes expands existing logic instead of reusing components.
• Editor limitations: No “go-to definition,” inconsistent formatting, and less control compared to IDEs like VSCode or Cursor.
• Iteration overhead: Subsequent generations may duplicate structures rather than refactor them.

While you can request improvements directly in Lovable, the editing experience still feels more suited to high-level iteration than fine-grained code work.

In practice, the best results came from using Lovable for generation and debugging, and Cursor for refactoring and standardization.

The Figma integration and design alignment

In early 2025, Lovable introduced direct integration with Figma, allowing design files to be translated into code.

We didn’t use that feature in this project, mainly because the designer joined after development had already started. The integration requirements—consistent layer naming, reusable components, shared styles—needed to be defined beforehand.

However, the design itself was well-structured and visually strong. The only limitation was timing: the integration required an alignment step we simply couldn’t prioritize during the initial build.

In future projects, planning that connection from the beginning will make the Figma-to-Lovable workflow even more efficient.

Multilingual prompts and code consistency

Because my native language is Brazilian Portuguese, I often interact with Lovable in Portuguese.

It handled bilingual input remarkably well, seamlessly understanding both English and Portuguese instructions.

However, once Portuguese was introduced, the AI began generating comments and text in mixed languages, even after explicit requests to keep everything in English.

Unlike Cursor or ChatGPT, Lovable doesn’t yet seem to have a memory feature to enforce style or language preferences across sessions. This is an area where long-term consistency could still improve.

Lessons learned

• Planning is critical: starting directly in build mode increases cost and iteration overhead.
• AI can reason visually and logically: Lovable accurately adjusted color, layout, and spacing with minimal prompts.
• Security review tools matter: built-in security analysis prevented real data exposure.
• Human expertise amplifies AI output: refactoring and modularization improved code quality.
• Design alignment early on enables automation: a consistent Figma structure is key to future integrations.
• Multilingual handling is strong, but consistency controls are still needed.

Final thoughts

In less than a month, this project evolved from static PDFs to a fully functional, secure, multi-wallet lead capture platform powered primarily by AI.

The process revealed that AI can already understand design intent, apply technical best practices, and collaborate interactively.

However, it also reaffirmed that experienced developers and designers remain essential — not because AI can’t build, but because crafting maintainable, scalable, and coherent software still requires human judgment.

AI isn’t replacing engineers; it’s becoming a powerful extension of them, capable of transforming how we design, build, and ship products.