Skip to content
TheChatArchiveThe Chat Archive
Claudeclaude-3-5-haiku-20241022· AnthropicHugging Face LMArena Human Preference 140K

Quickly assemble a bunch of agents and have them asynchronously vibe code a program that…

From a Chatbot Arena battleThe same person sent this prompt to two anonymous models at once. Compare it with Geminigemini-2.0-flash-001’s answer.
  1. User

    Quickly assemble a bunch of agents and have them asynchronously vibe code a program that does something related to mahjong tiles

  2. Claude Assistant

    I'll help you sketch out a collaborative coding approach for a Mahjong tile-related project. Here's a conceptual design for an asynchronous, multi-agent code development scenario:

    from dataclasses import dataclass
    from enum import Enum, auto
    from typing import List, Dict
    import random
    
    class TileSuit(Enum):
        CHARACTERS = auto()
        BAMBOO = auto()
        DOTS = auto()
        WINDS = auto()
        DRAGONS = auto()
    
    @dataclass
    class MahjongTile:
        suit: TileSuit
        value: int
        is_honor: bool = False
    
    class TileGenerator:
        @staticmethod
        def generate_standard_set() -> List[MahjongTile]:
            tiles = []
            # Agent 1: Implement character tiles
            for value in range(1, 10):
                tiles.extend([MahjongTile(TileSuit.CHARACTERS, value)] * 4)
            
            # Agent 2: Implement bamboo tiles
            for value in range(1, 10):
                tiles.extend([MahjongTile(TileSuit.BAMBOO, value)] * 4)
            
            # Agent 3: Implement dot tiles
            for value in range(1, 10):
                tiles.extend([MahjongTile(TileSuit.DOTS, value)] * 4)
            
            # Agent 4: Implement honor tiles
            honor_tiles = [
                MahjongTile(TileSuit.WINDS, 1, True),  # East
                MahjongTile(TileSuit.WINDS, 2, True),  # South
                MahjongTile(TileSuit.WINDS, 3, True),  # West
                MahjongTile(TileSuit.WINDS, 4, True),  # North
                MahjongTile(TileSuit.DRAGONS, 1, True),  # Red
                MahjongTile(TileSuit.DRAGONS, 2, True),  # Green
                MahjongTile(TileSuit.DRAGONS, 3, True)   # White
            ]
            tiles.extend(honor_tiles * 4)
            
            return tiles
    
    class TileShuffler:
        @staticmethod
        def shuffle_tiles(tiles: List[MahjongTile]) -> List[MahjongTile]:
            # Agent 5: Implement advanced shuffling algorithm
            random.shuffle(tiles)
            return tiles
    
    class MahjongHand:
        def __init__(self, tiles: List[MahjongTile]):
            self.tiles = sorted(tiles, key=lambda x: (x.suit.value, x.value))
        
        def detect_sets(self) -> Dict[str, List[MahjongTile]]:
            # Agent 6: Implement set detection logic
            # Detect potential melds (sets, runs, etc.)
            pass
    
    def main():
        # Orchestrator Agent
        tile_set = TileGenerator.generate_standard_set()
        shuffled_tiles = TileShuffler.shuffle_tiles(tile_set)
        
        # Deal hands
        player_hands = [
            MahjongHand(shuffled_tiles[i:i+13]) for i in range(0, 52, 13)
        ]
    
    if __name__ == "__main__":
        main()
    

    This code represents a collaborative approach where different "agents" might work on specific components:

    • Agent 1-3: Tile generation for different suits
    • Agent 4: Honor tiles implementation
    • Agent 5: Tile shuffling mechanism
    • Agent 6: Set detection logic

    The code provides a framework for Mahjong tile management with asynchronous-style development in mind. Each "agent" could theoretically work on their component independently, focusing on specific tile-related tasks.

    Note: This is a conceptual implementation and would require further development for a complete Mahjong game system. The set detection method is left as a placeholder for future implementation.

    Would you like me to elaborate on any specific aspect of this Mahjong tile system?

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.