Meet Claire: The Shield against Vibe Debts

AI makes coding fast. Claire makes sure you're building the right thing. She scans your codebase, stress-tests your idea, and gets PM & Tech Lead aligned, before a single line of code is written.

Comment

Claire : the Agent that help eliminate token-waste

GitLab Duo Agent Platform Hackathon 2026 Submission Built to eliminate the biggest risk in modern software development: building the wrong thing.

Demo Video

Watch the 2-minute walkthrough to see Claire in action — from raw PM idea to approved architectural decision:

Claire Demo Video

The Problem Claire Solves

AI coding tools like v0 and Lovable let Product Managers dream up features in seconds. That's exciting — but it creates a new danger.

Building software is now 10x faster. Building the wrong thing is now 10x easier.

In the era of "Vibe Coding," a PM can describe a feature, watch it come to life visually, and hand it to an engineer — only to discover it conflicts with the existing architecture, depends on infrastructure that doesn't exist, or duplicates something that's already been built. The codebase never lied. Nobody checked.

This is the Discovery Phase problem: the gap between "I have an idea" and "this is technically feasible."

Claire bridges that gap. She is an AI Technical Architecture Assistant built directly into GitLab Duo. Before a single line of code is written, Claire scans your codebase, asks the right questions, and gives the Product Trio — PM, Designer, and Tech Lead — a shared technical reality check.

What Claire Does

Claire automates the Discovery Phase of the SDLC through two components that work together:

Component Where it runs What it does
Claire (Duo Chat Agent) GitLab Duo Chat sidebar Guides the PM from raw idea → analyzed issue with 3 technical proposals
Claire Flow (Ambient Flow) Triggered by @mention in issue comments Handles the Tech Lead review cycle (approve, revise, or clarify)

Together they cover the full loop:

PM has an idea
     ↓
Claire scans the codebase
     ↓
PM answers clarifying questions
     ↓
Claire estimates effort and risks
     ↓
Claire creates a GitLab issue with full analysis + 3 proposals
     ↓
Tech Lead reviews and decides (via @mention)
     ↓
Claire finalizes the decision or revises proposals
     ↓
Issue is ready for implementation

How Claire Works — Step by Step

Phase 1: PM Conversation (Duo Chat)

This phase happens inside the GitLab Duo Chat sidebar. The PM talks to Claire like a colleague.

Step 1 — Quick Feasibility Scan

The PM describes a feature idea. Claire immediately:

  • Reads .gitlab/team.yml to learn who the PM and Tech Lead are
  • Scans the repository tree to understand the project structure
  • Searches relevant source files, configs, and dependencies
  • Replies with a plain-language feasibility summary:
    • What already exists in the codebase
    • What gaps would need to be filled
    • An initial impression: Feasible / Feasible with effort / Major challenges

Step 2 — Clarifying Questions

Claire asks 2–4 targeted questions to uncover blind spots before estimating:

  • Scope: what's in and out of this feature?
  • Constraints: performance requirements, timeline, budget?
  • Edge cases: what happens when things go wrong?
  • Integrations: does this touch external services?

The PM answers, and Claire continues.

Step 3 — Rough Estimation

Based on the codebase scan and the PM's answers, Claire provides:

  • Complexity rating (Low / Medium / High)
  • Breakdown of effort areas
  • Key technical risks
  • External dependencies or blockers

Then Claire asks: "Would you like me to create an issue with a detailed analysis and technical proposals for the Tech Lead to review?"

Step 4 — Issue Creation

When the PM says yes, Claire:

  1. Does a deeper codebase scan
  2. Creates a GitLab issue with the full technical analysis in the description
  3. Posts 3 technical proposals (Option A, B, C) as a comment — so the description stays clean and proposals stay versioned in comments
  4. Assigns the issue to the Tech Lead for review
  5. Confirms to the PM in chat with next steps

Phase 2: Tech Lead Review (Ambient Flow)

This phase is triggered automatically when the Tech Lead @mentions the flow in an issue comment. No manual steps needed.

How to trigger it:

The Tech Lead posts a comment on the issue like:

@ai-claire-architecture-decision-flow-gitlab-ai-hackathon I'd like to go with Option B. Looks good.

Claire reads the full issue thread and classifies the Tech Lead's response into one of three states:

Tech Lead's Response Claire's Action
Approval — picks an option, says "looks good", "let's go with B", etc. Adds an "Approved Approach" section to the issue description, reassigns the issue to the PM, posts a summary comment
Pushback with details — pushes back AND explains why (e.g. "Option A is too costly, consider using Redis instead") Posts 3 revised proposals in a new comment that address the specific concerns
Pushback without details — vague rejection (e.g. "I don't think this will work") Asks the Tech Lead for specifics: which aspects? what constraints? any alternative direction?

The flow loops until the Tech Lead approves. Once approved, the issue is fully documented and handed back to the PM for implementation planning.

State Machine

Claire tracks progress through states stored in a Claire Context block inside each issue comment:

State 2  → Technical proposals posted, waiting for Tech Lead
State 3a → Decision finalized (approved), handed back to PM
State 3b → Awaiting pushback details from Tech Lead

This context block is what allows the ambient flow to pick up exactly where the conversation left off, even days later.

Built With

  • gitlabduo
  • yaml
Share this project:

Updates