Case Studies

Short quizzes invite people to reveal preferences through different kinds of interaction: instinctive swipes, ordered choices, and quick trade-offs. The goal was not only variety. It was to make each quiz mechanic feel distinct while still belonging to one coherent product.

Implementation-wise the different game modes offered to deeply dive into gesture-driven animations, making sure that they are performant and at the same time feel natural. To allow for finetuning, most of these animations were programmed by hand instead of LLM-supported.

Zelia is the app's AI conversation layer. Before a user enters that experience, they first encounter an explicit consent step for processing personal context. This was a product decision I advocated for, informed by building for European users and the sensitivity of AI-mediated conversations. At the same time it avoids an explicit privacy consent step in the onboarding, possibly narrowing the funnel.

The consent screen stays clear in intent, while carefully revealing an example conversation behind, giving the user a sneak peek of what he can expect.

The chat interface itself is kept clean, while still being able to render formatted content.

The live match flow begins with a QR code, so that the user can add another user to his list of connections. The main value comes however from how gracefully the product continues after the scan.

That means handling more than one outcome: someone may already be inside the app, or they may still be at the edge of it. This is necessary from product side to not introduce hard stops for (possible) users even if they do not have the app installed. And from the technical POV it merges web page, QR sharing and scanning, shareable URLs to user profiles all back to the app in one tight package.

In the connections flow, users review candidates and decide whether they want to launch a real match. That final interaction benefits from motion because it gives the decision a sense of weight and warmth.

As sole app engineer, I implemented DAIT's mobile application in React Native and Expo: the architecture, app structure, flow logic, gesture-heavy interactions, data handling, the integrations needed to support its product behavior.

As a founder, I was also part of deciding what deserved to exist at all. That overlap between product scoping and implementation is one of the main reasons this project represents me well.

Selected Implementation Peeks

useAnimatedReaction(
  () => activeIndex.value,
  (current, previous) => {
    if (current !== previous) {
      scheduleOnRN(handleQuestionChange, current)
    }
  },
  [quizData]
)

const onSwipeRight = () => handleResponse(question.id, 'green')
const onSwipeLeft = () => handleResponse(question.id, 'red')
const onSwipeDown = () => handleResponse(question.id, 'neutral')

function handleBarCodeScanned({ data }: { data: string }) {
  if (scannedRef.current)
    return

  if (isValidScannedData(data)) {
    const userId = extractUserIdFromScannedData(data)
    if (userId) {
      scannedRef.current = true
      Haptics.impactAsync(Haptics.ImpactFeedbackStyle.Medium)
      router.push(`/sharing/u/${userId}`)
    }
  }
}

const consentStatus = userInfo.assistant_consent.status
const isConsentActive = consentStatus === 'active'

return isConsentActive
  ? (
      <Button
        title={t('zelia_privacy.revoke_cta')}
        onPress={handleRevokeConsent}
      />
    )
  : (
      <Button
        title={activationActionTitle}
        onPress={handleReactivateConsent}
      />
    )

The product itself stays human-facing. What changed is the way I build, test, and inspect it.

Today I use DAIT as a real environment for exploring how coding agents can support React Native and Expo work without losing the discipline of verification.