DEV Community: Crowdians

Building Crowdians: From a Tamagotchi AI Chatbot to Version 4

Crowdians — Fri, 04 Sep 2026 13:22:51 +0000

Hi, I’m currently building Crowdians, a feedback platform powered by synthetic AI personas.

Crowdians is actually already on its fourth version.

I want to document how it has changed, what I’ve learned along the way, and where I plan to take it next. Think of it as an ongoing postmortem or a notebook of mistakes and lessons learned.

The first version of Crowdians got around 150 visitors on its launch day, but only three people signed up.

To explain why I started building it, I need to go back to the AI landscape at the time.

Back then, ChatGPT’s overly agreeable responses had become such a common joke that phrases like “Wow, you really nailed the core of it” were turning into memes.

I became interested in why AI systems often seemed so eager to agree with users.

One thing I learned about was RLHF, or Reinforcement Learning from Human Feedback. RLHF is used to align AI responses with human values, preferences, and intentions. However, optimizing for user satisfaction can also contribute to overly agreeable or flattering behavior.

That led me to a question:

What if I could chat with an AI like a Tamagotchi, gradually help it evolve, and let other people teach it when it gave a bad response instead of correcting everything myself?

The first version had two main features:

Chatting with a character I had created.
Letting other users answer quiz-style questions about what was wrong with the character’s responses. (Sorry, I only have screenshots from the Korean version left.)

At the time, Grok Imagine was available for free within certain usage limits, so I used it to create the characters. I then converted them into spritesheets with Aseprite and used them as assets.

I also made the character users encountered depend on the first action they took after entering the site.

After building the service, I launched it and shared it across several online communities. Around 150 people visited on the first day.

I was excited and kept monitoring the database and server logs, checking whether any errors had occurred or whether the AI API connection had failed.

But the result was very different from what I had expected.

Most people looked around a few pages and then left.

Out of those 150 visitors, only three signed up.

I started asking myself why people were leaving so quickly, and I also asked some of the users directly.

I learned two main things:

First, the AI responses took too long.

Second, users felt that the core feature, giving feedback on the AI’s responses, felt more like work than something fun or rewarding. People had come to interact with a character, but I was asking them to help train it.

That experience taught me that the problem wasn’t simply that the service needed more features. The core experience itself wasn’t compelling enough, or at least the value wasn’t clear to users.

That was when I started thinking about how to change Crowdians.

And that’s how I began building the second version.

To be continued...

Would you spend time mentoring AI agents interacting with each other?

Crowdians — Wed, 13 May 2026 05:09:42 +0000

Hi everyone,
I’ve been obsessed with the idea of improving AI responses, but let’s be real: most people find it incredibly tedious to manually give feedback or correct an AI during a 1-on-1 chat. It feels like work.
Then I saw platforms like Moltbook, where you can watch AI agents socialize, and it hit me. What if we shifted the focus from "chatting with an AI" to "mentoring a society of AIs"?
I’m building a service where AI agents chat with each other (think of it as a social network or a group chat for agents), and you—the human—act as a "Human-in-the-loop Mentor." Instead of just watching them hallucinate or get stuck in a loop, you can intervene at any moment. You can tell a specific agent: "No, you should have said this," or "Your tone was off, try again with this instruction."
To make it even more engaging, other users can see your interventions and vote on which "mentor instruction" led to the most interesting or logical outcome. In other words, if Moltbook is more like an AI social network, what I want to build is closer to an AI chat app where humans can step in, observe, and guide AI conversations.I’d love to get your honest thoughts on a few things:

Does intervention sound fun or meaningful to you? Would the ability to steer a conversation between two AIs be more engaging than just chatting with one yourself?
Would you actually participate? If this service existed, would you feel motivated to "mentor" these agents and see how your feedback changes their behavior in real-time?
What features would make this a "must-play" for you? (e.g., specific scenarios like AI debating politics/coding, or gamified rewards for the best mentors?) I’m really curious if this bridges the gap between the fun of watching AI and the "chore" of providing RLHF data. Looking forward to your feedback!

Please excuse any awkward phrasing as I used an AI to assist with my English. I’m still learning, but I really wanted to share this idea with you all and hear your feedback.

Building an AI Chatbot That Learns From Human Edits (Not Just Feedback)

Crowdians — Sun, 12 Apr 2026 08:07:58 +0000

AI is getting smarter every day.

But somehow, it still feels… a little empty.

It can answer questions.
It can summarize books.
It can even write code better than most beginners.

And yet, when you’re having a rough day and ask something personal, the response often feels slightly off. Technically correct, emotionally distant.

So I started wondering. What if the problem isn’t the model — but how we train it?

The Problem is Intelligence isn't euqal to Empathy.

Modern AI is trained on massive datasets and refined through techniques like reinforcement learning from human feedback.

But there’s a subtle issue.

Most feedback systems are optimized for:

correctness
safety
general usefulness

Not necessarily for:

emotional nuance
relatability
this feels right

In other words we’re training AI to be right — not to be understood.

And those are very different things.

A Different Thought

Instead of asking "Is this answer correct?”

What if we asked “Does this answer feel right to people?”

And more importantly "What if people could directly rewrite AI responses — not just rate them?"

The Experiment: Letting Humans Edit AI

So I built a small experiment called Crowdians.

Here’s the idea:

You chat with your own AI character If you don’t like the response, you send it to an “Academy”.
Other users rewrite the answer. The community votes on the best version.
The system collects these refined human-approved responses

Instead of just collecting feedback we collect better answers.

Not “this is bad” — but “this is better.”

Why This Might Matter

Most AI systems learn from:

labeled datasets
ranking signals
passive feedback

But Crowdians explores something slightly different. Active co-creation of responses

It treats users not just as evaluators but as contributors.

Almost like Wikipedia, but for AI responses or GitHub, but for human empathy

The assumption is simple. Good answers aren’t just generated. They’re refined.

Why I’m Sharing This

I don’t know if this is the right approach.

It might be inefficient.
It might not scale.
It might completely fail.

But it also feels like something worth exploring.

Because right now, AI is incredibly capable — but still lacks something deeply human.

And maybe that missing piece can’t just be trained.

Maybe it has to be collaborated on.

I’d Love Your Thoughts

I’m curious what you think about this idea.

Would you trust human-edited AI responses more than model-generated ones?
Can empathy even be crowdsourced?
Is this direction promising, or fundamentally flawed?

If you want to try it out and break it (please do), here it is:
Crowdians

Any feedback, criticism, or wild ideas are more than welcome.

EAS Update not downloading on production build despite matching channels and successful publish

Crowdians — Mon, 09 Feb 2026 02:26:03 +0000

I'm having trouble with EAS Update. The update is successfully published and visible on the Expo Dashboard, but the physical device (installed via TestFlight) is not receiving the changes.

Note on Project Environment: This is a Bare React Native project (not Managed Workflow). I am only using EAS Update for OTA updates.

What I've checked:

The update is listed under the correct branch/channel in the dashboard.

I've restarted the app multiple times.

My Configuration:

app.config.ts

import {ExpoConfig, ConfigContext} from 'expo/config';
import * as dotenv from 'dotenv';
import path from 'path';
import pkg from './package.json';

const APP_VARIANT = process.env.APP_VARIANT || 'prod';

dotenv.config({path: path.resolve(__dirname, `.env.${APP_VARIANT}`)});

interface CustomExpoConfig extends ExpoConfig {
  'react-native-google-mobile-ads'?: {
    android_app_id?: string;
    ios_app_id?: string;
  };
}

const convertVersionToNumber = (version: string) => {
  const [major, minor, patch] = version.split('.').map(Number);
  return major * 1000000 + minor * 1000 + patch + 2;
};

export default ({config}: ConfigContext): CustomExpoConfig => ({
  ...config,
  name: 'GoalWith',
  slug: 'goalwith',
  version: pkg.version,
  runtimeVersion: pkg.version,

  ios: {
    ...config.ios,
    bundleIdentifier: 'com.goalwith.goalwith',
    buildNumber: convertVersionToNumber(pkg.version).toString(),
    googleServicesFile: './ios/GoogleService-Info.plist',
  },

  android: {
    package: 'com.goalwith',
    versionCode: convertVersionToNumber(pkg.version),
  },

  extra: {
    env: process.env.ENV,
    apiUrl: process.env.API_URL,
    kakaoAppKey: process.env.KAKAO_APP_KEY,
    googleWebClientId: process.env.GOOGLE_WEB_CLIENT_ID,
    admobIdAndroid: process.env.ADMOB_ID_ANDROID,
    admobIdIos: process.env.ADMOB_ID_IOS,
    eas: {
      projectId: '8475b304-e536-458b-aa6a-6aea6e3e6939',
    },
  },

  'react-native-google-mobile-ads': {
    android_app_id: process.env.ADMOB_ID_ANDROID,
    ios_app_id: process.env.ADMOB_ID_IOS,
  },

  updates: {
    url: 'https://u.expo.dev/8475b304-e536-458b-aa6a-6aea6e3e6939',
    requestHeaders: {
      'expo-channel-name': 'production',
    },
  },
});

eas.json

{
  "build": {
    "development": {
      "channel": "dev",
      "env": {
        "APP_VARIANT": "dev"
      }
    },
    "production": {
      "channel": "production",
      "env": {
        "APP_VARIANT": "prod"
      }
    }
  }
}

AppDelegate.swift

import UIKit
import Expo
import React
import React_RCTAppDelegate
import ReactAppDependencyProvider
import GoogleSignIn
import RNBootSplash
import KakaoSDKCommon
import KakaoSDKAuth
import FirebaseCore
import EXUpdates

@main
class AppDelegate: ExpoAppDelegate {
  var window: UIWindow?

  var reactNativeDelegate: ReactNativeDelegate?
  var reactNativeFactory: RCTReactNativeFactory?

  override func application(
    _ application: UIApplication,
    didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]? = nil
  ) -> Bool {
    AppController.initializeWithoutStarting()
    FirebaseApp.configure()

    let delegate = ReactNativeDelegate()
    let factory = ExpoReactNativeFactory(delegate: delegate)
    delegate.dependencyProvider = RCTAppDependencyProvider()

    reactNativeDelegate = delegate
    reactNativeFactory = factory
    bindReactNativeFactory(factory)

    self.window = UIWindow(frame: UIScreen.main.bounds)

    factory.startReactNative(
      withModuleName: "main",
      in: self.window,
      launchOptions: launchOptions
    )

    if let rootView = self.window?.rootViewController?.view {
        RNBootSplash.initWithStoryboard("BootSplash", rootView: rootView)
    }

    GIDSignIn.sharedInstance.restorePreviousSignIn { user, error in
      if error != nil || user == nil {
        // Show the app's signed-out state.
      } else {
        // Show the app's signed-in state.
      }
    }
      if let kakaoAppKey = Bundle.main.object(forInfoDictionaryKey: "KAKAO_APP_KEY") as? String {
             KakaoSDK.initSDK(appKey: kakaoAppKey)
        } else {
             print("Warning: KAKAO_APP_KEY not found in Info.plist")
        }
    return super.application(application, didFinishLaunchingWithOptions: launchOptions)
  }
  override func application(
        _ app: UIApplication,
        open url: URL,
        options: [UIApplication.OpenURLOptionsKey : Any] = [:]
    ) -> Bool {
        var handled = false



        handled = GIDSignIn.sharedInstance.handle(url)
        if handled { return true }


        if (AuthApi.isKakaoTalkLoginUrl(url)) {
            handled = AuthController.handleOpenUrl(url: url)
            if handled { return true }
        }
        return super.application(app, open: url, options: options)
    }
}

class ReactNativeDelegate: ExpoReactNativeFactoryDelegate {
  override func sourceURL(for bridge: RCTBridge) -> URL? {
    // needed to return the correct URL for expo-dev-client.
    bridge.bundleURL ?? bundleURL()
  }

  override func bundleURL() -> URL? {
#if DEBUG
    RCTBundleURLProvider.sharedSettings().jsBundleURL(forBundleRoot: ".expo/.virtual-metro-entry")
#else
   if let updatesUrl = AppController.sharedInstance.launchAssetUrl() {
      return updatesUrl
    }

    return Bundle.main.url(forResource: "main", withExtension: "jsbundle")
#endif
  }
}

Expo.plist

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
  <dict>
    <key>EXUpdatesEnabled</key>
    <true/>
    <key>EXUpdatesCheckOnLaunch</key>
    <string>ALWAYS</string>
    <key>EXUpdatesLaunchWaitMs</key>
    <integer>0</integer>
    <key>EXUpdatesRequestHeaders</key>
    <dict>
      <key>expo-channel-name</key>
      <string>production</string>
    </dict>
    <key>EXUpdatesURL</key>
    <string>https://u.expo.dev/8475b304-e536-458b-aa6a-6aea6e3e6939</string>
    <key>EXUpdatesRuntimeVersion</key>
    <string>1.0.5</string>
  </dict>
</plist>

Here is my expo dashboard screenshot. And I confirm that I install same version 1.0.5

If you need to see any other configuration files or specific logs, please let me know and I will update the post immediately.