DEV Community: Sang

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

Sang — 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)

Sang — 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

Sang — 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.