English

Project Memory

See how condoo.Vibe maintains context about your project so new prompts build on existing pages, data, and design instead of starting over.

As your application grows, condoo.Vibe needs to understand more than your latest prompt.

Project Memory helps condoo.Vibe maintain context about the application you're building, so you can continue developing the same product without explaining everything from scratch every time.

It allows your conversations with condoo.Vibe to build on the work that has already happened.

Your project has context. Your next prompt doesn't start from zero.

Why Project Memory matters

Imagine you've spent several days building a CRM.

You've already created:

Now you ask:

Add an activity timeline to each lead.

Without project context, an AI would need you to explain what a lead is, how your application is structured, how users work with leads, and how the new feature should fit into the existing product.

condoo.Vibe works within the context of the project you're already building.

That makes continued development much more natural.

Your project is more than a conversation

When you work inside an condoo.Vibe project, condoo.Vibe isn't treating every prompt as an entirely new application.

Your existing project provides important context for future work.

This can include things such as:

This helps condoo.Vibe understand how a new request relates to what already exists.

Continue where you left off

Suppose you initially ask:

Build a CRM for a real estate agency. Agents should be able to manage leads, properties, deals, and follow-ups.

condoo.Vibe builds the initial product.

Later, inside the same project, you can say:

Add a notes section to each lead.

You don't necessarily need to repeat:

This is a real estate CRM and it has leads...

The existing project gives condoo.Vibe context for understanding what you're referring to.

Later, you might say:

Show the five most recent notes on the dashboard.

condoo.Vibe can work with the existing application rather than treating the request as an unrelated feature.

Project Memory helps your application evolve

Project Memory becomes increasingly valuable as your application becomes more sophisticated.

Your development process might look like this:

  1. Start

    Build a client portal for a marketing agency.

    condoo.Vibe creates the initial product.

  2. Expand

    Add projects for each client.

    condoo.Vibe works within the existing portal.

  3. Connect

    Allow each project to have tasks, files, and comments.

    The new functionality builds on the existing project structure.

  4. Automate

    Notify clients by email when their project status changes.

    condoo.Vibe connects the new requirement to functionality you've already created.

The product becomes richer over time without every request needing to redefine the entire application.

Memory doesn't mean you should be vague

Project context allows you to avoid unnecessary repetition, but clear instructions still matter.

For example:

Fix the dashboard.

is still ambiguous.

condoo.Vibe may understand what dashboard you're referring to, but it doesn't necessarily know what you think is wrong.

A better prompt would be:

The dashboard feels too crowded. Keep the existing metrics, but move recent activity below the project list and give upcoming deadlines more visual prominence.

Project Memory provides context.

Your prompt still provides intent.

Both matter.

Reference existing parts naturally

When you're working inside an established project, you can refer to existing features directly.

For example:

Add search to the Leads page.

Show the current user's avatar in the existing sidebar.

Add the new status to the same filters used on the Projects page.

Use the existing confirmation dialog when deleting a customer.

Add this metric beside the existing revenue KPI.

These instructions tell condoo.Vibe how new work should relate to the product that already exists.

Tell condoo.Vibe what should remain unchanged

Context becomes particularly important when modifying mature applications.

Suppose you say:

Redesign the customer detail page.

That's a broad instruction.

If parts of the page already work well, give condoo.Vibe boundaries:

Redesign the customer detail page to improve information hierarchy. Keep the existing customer fields, API behavior, editing functionality, and activity timeline unchanged. Only restructure the presentation.

Now condoo.Vibe knows both:

What should change

and

what should be preserved.

Project Memory and design consistency

Context also helps condoo.Vibe build new features that belong in the existing product.

If your application already has:

new features should generally work with those established patterns instead of creating an entirely different interface.

For example:

Add an Invoices page. Follow the existing dashboard's visual system and reuse existing UI patterns wherever appropriate.

This helps reinforce consistency as the application grows.

Project Memory and your data model

For dynamic applications, existing data structures are an important part of project context.

Suppose your application already has:

Customers → Projects → Tasks

and you ask:

Add file attachments to tasks.

condoo.Vibe should consider how the new functionality relates to the existing Task entity and application workflow.

For more significant data changes, however, you should consider using Plan Mode.

For example:

We need to allow a single task to belong to multiple projects. Analyze how this affects the existing data model and application before changing anything.

That is a structural change where deeper planning can be valuable.

Use the same project when evolving your application

If you're continuing to build the same product, continue working inside the existing condoo.Vibe project.

Don't create a new project simply because you're adding another feature.

For example, if you've built a booking application and now want to add:

those features should generally continue inside the same project.

This allows condoo.Vibe to work with the application that already exists.

Create a separate project when you're actually building a separate product or intentionally starting from a new foundation.

When to remind condoo.Vibe

Even with project context, there are situations where repeating an important requirement is useful.

Especially when the requirement is critical to the change you're requesting.

For example:

Add reporting to the admin dashboard. Remember that all data must remain isolated by workspace: an administrator must never see another workspace's data.

Or:

Add image uploads to property listings. Preserve the existing Cloudinary integration rather than introducing another storage provider.

Or:

Redesign the onboarding flow, but keep Google and email/password authentication exactly as they work now.

You're not repeating the entire project.

You're highlighting the context that matters most to the current task.

When condoo.Vibe seems to misunderstand the project

If condoo.Vibe's response suggests that it has misunderstood something important, correct the assumption explicitly.

For example:

That's not how this project works. Deals always belong to a workspace and must also be linked to an existing lead. Keep that relationship and update your approach.

For a larger misunderstanding, use Explore or Plan Mode to inspect the existing application before making changes.

For example:

Before changing anything, analyze how Leads, Deals, and Workspaces currently relate to each other and explain the existing implementation.

Then decide what should happen next.

Project Memory and long-running applications

As a product grows, your requests often become less about generating something new and more about evolving what already exists.

You may move from:

Build a CRM.

to:

Add team management.

then:

Add reporting.

then:

Add subscriptions.

then:

Improve onboarding based on customer feedback.

then:

Add an AI assistant that can summarize customer activity.

The product changes, but it remains the same project.

Project Memory helps condoo.Vibe work within that evolving context.

Context + instruction + intent

A useful mental model is:

Project Memory

What already exists.

Your prompt

What you want now.

condoo.Vibe's reasoning

How the new request should fit into the product.

=

The next version of your application

This is what makes iterative development with condoo.Vibe possible.

Best practices

To get the most from Project Memory:

You don't need to explain your entire application with every prompt.

Give condoo.Vibe the new information and decisions that matter for the work you're doing now.

Next: Iterating on Your App

Project Memory allows condoo.Vibe to understand the application you're already building.

Next, we'll look at how to use that context effectively to iterate on your app: improving designs, adding features, changing workflows, and evolving your product without starting over.

Iterating on your app

Evolve your product through focused, follow-up changes.