I didn’t start with a plan

I started with curiosity.

I wanted to explore what it really meant to build with AI — not just generate ideas or snippets, but actually design, develop, and ship a product end-to-end.

I already had a few ideas in mind, but I was looking for a space where AI could unlock something fundamentally different.

The book summary space stood out.

It felt like a domain where the value wasn’t just in writing summaries, but in the technique of extracting knowledge from books. If that technique could be modeled, AI could potentially generate insights at scale.

So I started building.

The first version felt magical

I began with no-code and AI-assisted tools like Lovable and Bolt.

The promise was simple:

Go from idea to product — fast.

I prompted Lovable to create a book summary app.

It worked almost instantly.

There was a text input field. You entered a book name, and it generated a summary.

At first glance, it felt impressive.

But only at first glance

The moment I looked closer, things started breaking.

• It generated summaries for anything — even non-existent books

• It hallucinated freely, with no checks

• There was no autocomplete, no suggestions

• No memory — it generated the same book summary again and again

• Content felt repetitive and unstructured

It worked.

But it wasn’t a product.

Trying to fix it (and hitting limits)

I started fixing things within Lovable.

• Improved some UI

• Set up a basic Supabase database

But before I could go further…

I ran out of credits.

That was the first signal.

This approach wouldn’t scale.

The messy middle

So I tried a different approach.

I downloaded the code and moved it into my own environment.

Now I was:

• prompting GPT

• copying code

• testing in VS Code

• going back again

It worked.

But it was slow.

Too much back and forth.

Too much friction.

I needed AI inside the system

That’s when I moved to GitHub Copilot.

Instead of asking AI to generate outputs…

I started asking it to understand the system.

Reality check: the code wasn’t ready

I asked Copilot to audit the entire codebase.

The result was expected:

• Logic gaps everywhere

• No clear structure

• Important calls happening on the frontend

• No scalability or collaboration readiness

It looked like a product.

But it wasn’t built like one.

The shift: from outputs to systems

This is where everything changed.

I stopped asking:

“Generate this feature”

And started asking:

“How should this system work?”

Rebuilding, step by step

I began restructuring everything.

• Asked Copilot (GPT-4.1) for plans before changes

• Implemented changes step by step

• Introduced proper architecture

Building the foundation

I set up:

• GitHub repo → version control

• Netlify pipeline → deployment

• Supabase backend → database + functions

Now it was no longer just code.

It was a system.

Fixing the core problem: bad data

To solve hallucination and validation:

I integrated Open Library.

Now:

• Books were real

• Metadata was accurate

• The system had a source of truth

Designing the intelligence layer

On top of that, I built a structured GPT-4.1 layer.

Prompts were no longer generic.

They were designed.

• Fiction → different structure

• Non-fiction → different structure

Now outputs were:

• consistent

• readable

• meaningful

Moving logic where it belongs

The biggest shift:

I moved critical logic to the backend.

Using Supabase Edge Functions, I ensured:

• validation happens server-side

• generation happens server-side

• data flows correctly

Not on the frontend.

It finally felt like a product

The app started changing.

It stopped feeling like a demo.

And started behaving like something real.

But it still wasn’t enough

Once the base functionality was stable and the UI was decent…

The product was doing its job.

But that’s all it was doing.

It didn’t have much more to offer.

I had ideas.

But I didn’t have the time.

Then collaboration changed everything

That’s when my friend and flatmate Devesh got involved.

He’s a developer exploring vibe coding.

He jumped in.

And something surprising happened.

The system worked

He was able to:

• understand the codebase quickly

• set things up easily

• start pushing changes immediately

No friction.

No confusion.

Because the system was structured.

We started building together

And things moved fast.

We added:

• Login with Google

• Library → save books

• Streaks → build habit

• Reading lists → curated content

It became something people could return to

The product was no longer just:

“Generate summary”

It became:

“Engage with knowledge”

The real insight

This entire journey led to one realization:

AI makes production extremely fast.

But it needs direction.

A lot of it.

Without structure:

→ it generates outputs

With structure:

→ it builds products

And that difference is everything.

What this project really became

Bookgist.club started as an experiment.

But it turned into something else.

A way of working.

A way of thinking.

The real question

What does it actually take to build a real product with AI?

Not just prototypes.

Not just demos.

But something that works

The answer

AI doesn’t replace craft.

It demands it.

Just in a different form.