Why developers reject black-box AI summaries, and how we threaded exact conversational quotes through our CQRS pipeline into mobile evidence cards

The quickest way to make developers distrust an AI tool is to give them a black box.

Imagine your mobile phone buzzes during a sprint:

⚠️ "Divergence detected: Alice and Bob disagree on database architecture."

What is the very first question every engineer asks?

"Wait, what did Alice actually say? Did she actually commit to Postgres, or was she just spitballing ideas in the chat?"

If your app simply asserts: "Trust me, the AI noticed a conflict," developers will immediately dismiss it as a hallucination.

To win the Next Gen Track and Design Award at Shipaton 2026, we knew our radar couldn't just proclaim that a divergence existed. It had to show its work.

Here is how we architected full conversational provenance through our CQRS pipeline and surfaced verbatim evidence directly on our mobile radar cards.

The Problem: When AI Normalization Erases Truth

When Gemini 1.5 Flash parses a human message like:

"I think we should probably stick with Postgres for the database sprint."

It normalizes the intent into a clean object:

{
  "topic": "Database",
  "choice": "PostgreSQL"
}

Normalization is essential for our deterministic set-theory kernel to compare choices mathematically. But if you throw away the original sentence, you destroy the human context.

Was it an aggressive decision? A tentative suggestion? A definitive architecture lock?

[ Raw Chat String ]
        │
        ▼
"I think we should stick with Postgres for the sprint"
        │
        ▼
┌─────────────────────────────────────────────────────────────┐
│                 GEMINI 1.5 FLASH EXTRACTOR                  │
│   Extracts: { topic: "Database", choice: "PostgreSQL" }     │
└─────────────────────────────┬───────────────────────────────┘
                              │
                              ▼
┌─────────────────────────────────────────────────────────────┐
│                 IMMUTABLE CQRS SIGNAL PAYLOAD               │
│   Preserves BOTH normalized choice AND verbatim quote:      │
│   • topic: "Database"                                       │
│   • choice: "PostgreSQL"                                    │
│   • verbatim: "I think we should stick with Postgres..."    │
└─────────────────────────────┬───────────────────────────────┘
                              │
                              ▼
┌─────────────────────────────────────────────────────────────┐
│               MOBILE RADAR CARD (Show Your Work)            │
│   • Alice: "I think we should stick with Postgres..."       │
│            → Stated choice: PostgreSQL                      │
│   • Bob:   "Let's spin up Mongo for rapid prototyping"      │
│            → Stated choice: MongoDB                         │
└─────────────────────────────────────────────────────────────┘

1. Threading Verbatim Quotes Through the Kernel

To keep our evidence traceable, we updated our Signal contract and projection engine to treat the raw quote as a first-class citizen alongside the extracted choice:

export interface RealityState {
  members: string[];

  ownership: {
    ownerId?: string;
  };

  decisions: {
    actorId: string;
    topic: string;
    choice: string;
    verbatim?: string; // Original human statement preserved forever
  }[];
}

When our RealityProjection.replay() evaluates the timeline, it maps the verbatim quote directly into current reality:

} else if (signal.type === 'decision_stated') {
  const idx = state.decisions.findIndex(
    d =>
      d.actorId === signal.actorId &&
      d.topic === signal.payload.topic
  );

  if (idx >= 0) {
    state.decisions[idx].choice = signal.payload.choice;
    state.decisions[idx].verbatim = signal.payload.verbatim;
  } else {
    state.decisions.push({
      actorId: signal.actorId,
      topic: signal.payload.topic,
      choice: signal.payload.choice,
      verbatim: signal.payload.verbatim
    });
  }
}

2. The Evidence View: Mobile UI Craft

When our ConsensusGapDetector finds a conflict, it packages the exact decisions that caused it.

On the mobile screen (app/radar.tsx), we render this evidence list directly above the resolution buttons:

{radarState.gap?.evidence &&
  radarState.gap.evidence.length > 0 && (
    <View style={s.evidenceList}>
      {radarState.gap.evidence.map((ev, i) => (
        <View key={i} style={s.evidenceRow}>
          <Text style={s.evidenceActor}>
            {ev.actorId}
          </Text>

          <View style={s.evidenceContent}>
            {ev.verbatim ? (
              <Text style={s.evidenceVerbatim}>
                "{ev.verbatim}"
              </Text>
            ) : null}

            <Text style={s.evidenceChoice}>
              Stated choice: {ev.choice}
            </Text>
          </View>
        </View>
      ))}
    </View>
  )}

Typographic Polish in Dark Mode

To make scanning effortless in high-pressure collaborative sprints:

• The Actor: Styled with high-contrast label tokens (...type.label, uppercase tracking).
• The Verbatim Quote: Rendered in an italic body style (...type.body, fontStyle: 'italic') giving it the feeling of a direct quote.
• The Extracted Choice: Rendered in monospace code font (Platform.OS === 'ios' ? 'Menlo' : 'monospace') so developers immediately distinguish between natural language conversation and normalized logic.

┌─────────────────────────────────────────────────────────────┐
│ ⚠️ DRIFT DETECTED: Database Incompatibility                 │
│                                                             │
│ ALICE                                                       │
│ "I think we should stick with Postgres for the sprint."     │
│ Stated choice: PostgreSQL                                   │
│                                                             │
│ BOB                                                         │
│ "Let's spin up Mongo for rapid prototyping."                │
│ Stated choice: MongoDB                                      │
│                                                             │
│ [ Choose PostgreSQL ]   [ Choose MongoDB ]   [ Discuss ]    │
└─────────────────────────────────────────────────────────────┘

Answering the Judge's Toughest Question

During hackathon presentations, judges often suspect one of two extremes:

1. "That's just a hardcoded if-statement."
2. "That's an unreliable AI guessing conflicts."

The "Show Your Work" evidence card answers both criticisms in a single glance:

• It proves the intelligence is real, because the user typed natural conversational sentences that were parsed accurately.
• It proves the reasoning is deterministic and transparent, because every flag links directly to verifiable human quotes rather than an unexplained black-box summary.

The RevenueCat Connection: Historical Audit Trails

Why is verbatim tracking crucial for our RevenueCat monetization strategy?

Free users see verbatim evidence on active, unresolved gaps to help them align quickly in real-time.

When a team upgrades to Isolyne Pro via RevenueCat, our engine unlocks the Historical Audit Trail:

• Complete access to past resolved debates.
• One-click export of markdown Architectural Decision Records (ADRs) containing the date, the final consensus, and the verbatim quotes of every team member involved.

Subscribers gladly pay for Pro because it transforms fleeting team chat into an immutable, corporate-grade record of technical governance.

In Part 9...

How do you talk to developers when things go wrong without sounding like an adversarial compiler?

In Part 9, we’ll explore Empathetic UX—how we rewrote all internal CI error jargon into collaborative "Barrier-to-Bridge" microcopy.