Foundit

Foundit helps teams safely combine AI-generated software changes by explaining conflicts in normal language and turning two ideas into one working app.

Comment

Inspiration

What it does

How we built it

Challenges we ran into

Accomplishments that we're proud of

What we learned

What's next for Foundit

Inspiration

AI has made it incredibly easy for one person to build software. But the moment two people use AI to change the same app, collaboration becomes messy.

One teammate may overwrite another person’s work. Two individually good prompts can create incompatible features. Existing tools explain these problems using branches, files, and lines of code, which can be confusing for people who build primarily through natural-language prompts.

We built Foundit to make vibe coding multiplayer.

What it does

Foundit helps two teammates safely combine changes made with AI.

Each teammate describes what they want in normal language. Foundit then:

  • Creates a separate product version for each idea
  • Shows what each teammate changed
  • Explains the customer-facing impact
  • Detects incompatible product behavior
  • Asks the team one clear question when a decision is needed
  • Recommends a solution that can preserve both ideas
  • Produces one merged version
  • Runs safety checks and creates a rollback point

In our demo, Maya requests a fast one-page checkout with express payment. At the same time, Theo requests discount codes and address verification.

Foundit recognizes that Maya removed additional checkout steps while Theo introduced an address-verification step. Instead of displaying a wall of conflicting code, Foundit asks how the shipping flow should work.

The team can choose to keep Maya’s version, use Theo’s version, or use Foundit’s recommendation: preserve the one-page checkout while verifying the address inline.

Foundit then produces a checkout containing express payment, discount codes, and address verification in one working experience.

How we built it

We built a functional vertical slice around an ecommerce checkout.

The application contains three main systems:

Intent engine

The intent engine converts supported natural-language requests into structured checkout behavior.

It currently understands requests involving:

  • One-page or multi-step checkout
  • Express payment
  • Discount codes
  • Address verification
  • Guest or account-only checkout
  • Order notes
  • Gift messages

Conflict and merge engine

Foundit compares the behavior requested by both teammates.

It detects direct conflicts, such as one teammate enabling a feature while another disables it. It can also detect semantic conflicts where the code may not overlap, but the resulting product experiences are incompatible.

After the team chooses a resolution, Foundit generates a deterministic merged checkout configuration.

Interactive interface

We created a complete interface where users can:

  1. Enter two teammate prompts
  2. Build both versions
  3. Preview each version
  4. Review the product changes
  5. Resolve incompatible behavior
  6. Merge both ideas
  7. Inspect the final checkout
  8. Roll back the result

The prototype uses a local Node.js API and a dependency-free HTML, CSS, and JavaScript frontend.

Challenges we faced

The biggest challenge was defining what an AI collaboration conflict actually means.

Traditional Git conflicts happen when two people edit overlapping lines. AI-generated changes can affect completely different files while still producing incompatible product behavior.

For example, “put checkout on one page” and “add a separate verification step” may not create a normal Git conflict. However, the two requests describe opposing user experiences.

We therefore had to compare the intention and behavior behind each change instead of only comparing code.

Another challenge was presenting the conflict without overwhelming non-developers. We redesigned the review experience around four simple questions:

  • Who requested this?
  • What will change?
  • What will the customer experience?
  • Does the team need to make a decision?

Accomplishments we are proud of

We are proud that Foundit is a functional prototype rather than only a design mockup.

Users can enter custom prompts, create two checkout versions, review real behavioral changes, resolve detected conflicts, and generate a merged result.

The project also has 14 automated tests covering the intent engine, merge engine, API, validation, static server, and complete browser workflow.

Most importantly, Foundit turns a technical merge conflict into a product decision that anyone on the team can understand.

What we learned

We learned that the biggest problem in AI-assisted collaboration is not generating more code. It is coordinating what everyone intended to build.

AI can quickly create two technically valid implementations, but it does not automatically know which behavior should win or whether both experiences make sense together.

We also learned that conflicts are much easier to resolve when they are explained as user experiences instead of code differences.

What’s next

Our current MVP proves the workflow through structured checkout behavior.

Next, we want to connect Foundit to real GitHub repositories and AI coding environments. Foundit would observe changes made by different coding agents, connect those edits to their original prompts, run isolated previews, detect behavioral conflicts, and propose a tested merge.

Our long-term goal is for Foundit to become the collaboration layer between people, coding agents, and production software.

Two teammates. Two AI workflows. One working app.

Built With

Share this project:

Updates

Submission history