TuyDui

AI-powered scope control that turns client briefs into traceable requirements, detects scope changes, maps their impact, and streamlines client approval.

Comment

Inspiration

Scope creep rarely starts with a huge change.

It starts with one message.

“Can we also add Google Login?” “Can we change this page?” “Can you include this too?”

The original brief may have been clear, but client projects do not live inside one PDF. They continue through LINE messages, emails, calls, and revised documents.

After enough changes, a simple question becomes surprisingly difficult:

Was this already part of the project, or are we doing new work?

When nobody can answer that clearly, teams can end up doing extra work for free, deadlines shift, and conversations with clients become harder than they need to be.

That is the problem we built TuyDui for.

What it does

TuyDui is an AI-assisted scope control workspace for client projects.

Instead of letting the project scope disappear across documents and chat messages, TuyDui creates a record of what the team actually agreed to.

The PM uploads the original client brief.

TuyDui extracts the requirements and keeps each one connected to its source, including the page and supporting text. The PM reviews them and confirms the original scope as a baseline.

Then the project starts.

When a client sends a new request through LINE or email, the PM can paste that message into TuyDui.

TuyDui compares the request against the current approved scope and suggests whether it is:

  • In Scope
  • Modified
  • New Scope
  • Ambiguous

But the important part is not just the label.

TuyDui shows what the new request relates to, what was previously approved, and which parts of the project may be affected.

The PM then makes the final decision.

If it is extra work, the PM can decide whether to include it or charge separately and record that decision as part of the project's history.

The AI does not decide what the client should pay.
It gives the PM the context needed to make that decision.

How we built it

We designed TuyDui around a simple rule:

AI proposes. The PM decides. TuyDui remembers.

We did not want to build another chatbot where every request becomes a separate conversation.

Instead, TuyDui turns the client brief into structured requirements.

The first approved scope becomes Baseline V1.

That baseline stays unchanged.

When the PM later approves a change, the change becomes part of the Current Approved Scope.

So when another request arrives, TuyDui does not compare it only with an old PDF. It checks it against what the project has actually approved up to that point.

This creates a chain from:

Source → Requirement → Project Work → Responsibility → Change

and gives every later scope decision context.

Challenges we ran into

The hardest question was not how to make AI detect a change.

It was:

How much authority should we give the AI?

A model can confidently say that something looks like new scope, but that decision can affect deadlines, responsibilities, and money.

We did not think AI should make that decision for the project manager.

So instead of building an automatic scope judge, we built a review system.

TuyDui suggests the classification, shows the supporting context, and lets the PM make the final call.

Another challenge was handling time.

A project does not have only one scope.

It has the scope that existed on day one, and the scope the team has agreed to today.

That is why TuyDui keeps the original baseline immutable while allowing the current approved scope to evolve.

Accomplishments that we're proud of

The biggest accomplishment for us is that TuyDui connects a process that normally happens across multiple disconnected places.

Brief → Requirements → Baseline → Client Request → Scope Comparison → PM Decision → History

Instead of searching through an old PDF, scrolling through LINE, checking email, and trying to remember what was agreed on, the PM can review the change in the context of the project.

We also deliberately avoided turning TuyDui into another Jira, ClickUp, or general-purpose project management tool.

TuyDui focuses on one problem:

What changed from what we agreed to?

And it keeps the answer tied to the evidence.

What we learned

While building TuyDui, we realized that scope creep is not really caused by a lack of messages or documents.

Teams already have plenty of those.

The missing piece is the connection between them.

A new client message only becomes useful when you can connect it back to the requirement it affects, the scope that was approved, and the decision the team made afterward.

We also learned that AI does not always need to make the final decision to be useful.

For high-impact project decisions, helping a human understand the situation can be more valuable than trying to replace them.

What's next for TuyDui

Our next step is to make capturing scope changes even more natural.

Instead of manually moving information between client communication and the project workspace, we want TuyDui to connect more closely with the tools teams already use.

We also want to improve change comparison, project history, and client review so that a team can move from:

“Did we agree to this?”

to:

“Here is exactly what we agreed to, what changed, and what we decided.”

That is the direction we want TuyDui to grow in.

Built With

Share this project:

Updates

Submission history