Socket

Socket AI

Socket AI

Socket AI

Socket AI

Socket AI

Socket AI

Socket AI

Socket AI

Socket AI

Socket AI

Hands-free voice trigger & control multiple Claude Code Agents.

Hey guys, I run several Claude Code always-on agents and I wanted a way to trigger & control each one separately across my local network through my airpods, so I built [voice-channel](https://github.com/gtapps/voice-channel). It's a Claude Code Channel plugin with a dispatcher that you setup on your laptop. It allows you to trigger multiple Claude Code instances like: "hey Atlas, what is the status of gh issue 1", or "Hey Hermit, what is next on the task list" and Claude answers back. When you are running 8+ AI assistants across your local network it's really useful. You setup a trigger phrase like "Hey Atlas" for each Claude Code instance and whatever you say next routes that command into the specific running agent across the local network, each agent has it's own name, trigger phrases etc. The architecture is intentionally small: * Host Python dispatcher owns mic, speakers, VAD, STT, and TTS * Bun/TypeScript Claude Code Channel plugin connects to it over WebSocket like Discord & Telegram & Imessage official channel plugins * local Whisper/Piper by default * designed for local Claude Code agents, not as a generic Alexa clone Repo: [https://github.com/gtapps/voice-channel](https://github.com/gtapps/voice-channel) Would love feedback from macOS users to see if it's fully compatible as I wasn't able to test there.

Built a free self-hosted web terminal interface for Claude Code CLI

[https://github.com/HalfLucid/Claude-Code-Cli-WebTerminal](https://github.com/HalfLucid/Claude-Code-Cli-WebTerminal) I like using claude code CLI from my phone sometimes but I had issues with the method I was previously using (tailscale + termius) and decided to make something that works better for me. Sorry Windows only at the moment but feel free to fork/copy do whatever you want. I just wanted to share what I made in case someone else would like to use it too. Built this using claude code just specifying what I wanted If you do like it or have any feedback for things I should add let me know. Screenshots are in the github page. Would love to hear what you think. \-- Browser-based terminal over WebSocket with persistent, multi-tab sessions. Built for running [Claude Code](https://docs.anthropic.com/en/docs/claude-code) from any device — including mobile. [ASP.NET](http://ASP.NET) Core minimal API backend + xterm.js frontend. Connects your browser to a real PTY (pseudo-terminal) on the host machine. # Features [](https://github.com/HalfLucid/Claude-Code-Cli-WebTerminal#features) * **Persistent sessions** — PTY stays alive through disconnects, screen sleep, network loss. Reconnect and pick up where you left off. * **Multi-tab** — run multiple shells or Claude Code instances side by side with a tabbed interface. * **Claude Code integration** — launch Claude Code directly into any configured project directory. Open new or resume existing sessions. * **Mobile-friendly** — touch-optimized button overlay with configurable keys (Enter, arrows, Ctrl combos, Esc, Tab, etc.) and paginated layout. * **Native text input** — uses a virtual text entry layer that preserves your device's autocomplete, swipe typing, dictation, and IME support. Edits are transparently bridged to the PTY, so the full mobile keyboard experience works naturally in the terminal. * **Session ring buffer** — 256KB buffer replays recent output on reconnect so you never lose context. * **Basic auth** — credentials set on first run, encrypted with Windows DPAPI. * **Startup toggle** — optional Windows startup registration from the main screen. * **Configurable buttons** — reorder built-in buttons, switch Claude model/effort, and create custom buttons that send any text to the terminal. Custom buttons can trigger slash commands (e.g. `/review`), full prompts (e.g. `summarize all changes, commit, and create a pull request`), or any terminal input. # Usage [](https://github.com/HalfLucid/Claude-Code-Cli-WebTerminal#usage) 1. **PowerShell** — click "PowerShell" on the main screen to open a shell tab 2. **Claude Code** — add a project (name + directory), then use "Open Claude" or "Resume Claude" 3. **Tabs** — use the `+` button to open more sessions, click tabs to switch 4. **Mobile** — tap the arrow button on the right edge to expand the button overlay for touch-friendly input 5. **Remote access** — access from other devices on your network at `http://<your-ip>:7681` (works great with Tailscale) # Custom Buttons [](https://github.com/HalfLucid/Claude-Code-Cli-WebTerminal#custom-buttons) The button overlay on the right side is fully configurable via the **Buttons** settings on the main screen. * **Reorder** — move any built-in button up or down to change its position * **Model / Effort** — built-in popout buttons to switch Claude's model (`opus`, `sonnet`, `haiku`) or effort level * **Custom buttons** — add your own buttons with a label and a command string Custom button commands are sent directly to the terminal as text input, so they work with anything the active shell or CLI accepts. Examples: |Label|Command|What it does| |:-|:-|:-| |Review|`/review`|Triggers Claude Code's review skill| |Compact|`/compact`|Compresses Claude Code context| |Commit|`summarize all changes, commit, and create a pull request`|Full natural language prompt sent to Claude Code| |Status|`git status`|Runs a git command in a PowerShell tab|

Vibe coded an algorithm that prints money

Been quietly working on this for the past year. tried to write it by hand at the start but decided to do 90/10 vibe code because it was too much work for a simple person. The idea is simple: Binance announcements move markets instantly and violently. The edge is being first (and the hardest part of the project). The system detects announcements the moment they hit, classifies them in sub microsecond, and simultaneously fires orders on multiple exchanges. It runs 24/7 on a dedicated AWS server in Tokyo,took a lot of painful lessons with exchange APls, WebSocket quirks, and latency optimization to get here but it's been worth it. Here is some examples of profits (| started with very small amount and added very slowly). Couldn't have done it without codex/claude code so yeah... This is obviously not a financial advice ! Just wanted to share something I have been building

Inter-1 does streaming: real-time social signal detection from live video, audio & text

Hi – Filip from Interhuman AI here 👋 Last month we launched Inter-1, our multimodal model for detecting social signals from video, audio, and text. Today we’re making it work with video streams. We just released the Inter-1 Streaming API: a WebSocket endpoint that runs the full Inter-1 stack - 12 social signals, structured rationales, engagement, and conversation quality on live video while the conversation is unfolding. You stream WebM chunks in, and get back regular updates with detected signals. The model runs in sliding 8s windows with a sub-1.0 processing ratio, so it’s fast enough to power live coaching prompts, in-call overlays, and adaptive UI. It’s not meant to be a full voice agent on its own, it’s the behavioral signal layer you plug under whatever interaction system you’re building. If you’re working on sales/CS tooling, interview coaching, training, or live feedback products and want to experiment with real-time social intelligence, it might be worth looking into. Happy to answer questions or brainstorm use cases in the comments. submitted by /u/Sardzoski [link] [comments]

Claude suggesting me to sleep at 1:32 pm!!!

https://preview.redd.it/uf1cdhusb52h1.png?width=1413&format=png&auto=webp&s=f06a2790165a9a618cc67dca7dfd7f8b1af7c5ff Not a power nap, a good night sleep! :D ..............take it as humor not complaining!

I built a tool that shows you what GPT-2 is "thinking" in real-time as it generates 3D graph of concept activations per token [R]

Been going down a mechanistic interpretability rabbit hole for the past few weeks and ended up building this thing called AXON. The idea: every time GPT-2 generates a token, its residual stream gets passed through a Sparse Autoencoder (Joseph Bloom's pretrained SAE). The SAE decomposes it into human-interpretable feature: hings like "European geography", "capital cities", "French language" and streams those to the browser over WebSocket, where they show up as a live 3D force graph. Nodes = SAE features. Edges = features that fired together on the same token. Node brightness = activation strength. The whole graph evolves token by token. What surprised me most: type "The capital of France is" and you can literally watch geography features, proper noun features, and completion-pattern features light up before the word "Paris" even gets generated. It's not what the model outputs that's interesting it's what's happening right before it decides. Stack: TransformerLens + SAELens on the backend, FastAPI WebSocket for streaming, Three.js + 3d-force-graph on the frontend. Runs on CPU (~800ms/token) or GPU (~35ms on a 4050). Labels come from Neuronpedia's API and get cached locally. You can also swap in other models — GPT-2 medium/large/xl, Pythia variants, Gemma-2-2B — as long as there's a pretrained SAE for it in SAELens. GitHub: https://github.com/09Catho/axon Would love feedback and stars especially from anyone who's worked with SAEs before curious whether the co-activation edges are actually meaningful or just noise at this layer. submitted by /u/Financial_World_9730 [link] [comments]

9 things about Claude I wish someone had told me 10 years ago

1. **Be specific with context** — Instead of "fix this," say "fix the race condition in the WebSocket reconnect logic." The more precise your request, the better my output. 2. **Show me the code first** — I work best when I've read the relevant files. Open them or reference them so I have real context, not assumptions. 3. **Break big tasks into steps** — Instead of "refactor the entire auth system," ask me to handle one piece at a time. You'll get more accurate results and can course-correct early. 4. **Challenge my output** — I can be confidently wrong. If something feels off, ask me to explain my reasoning or double-check with "are you sure about X?" 5. **Use me for exploration** — Ask "how does this work?" or "what are the tradeoffs between A and B?" before jumping into implementation. I'm good at research. 6. **Give me constraints** — "Use no external libraries," "keep it under 50 lines," "match the existing pattern in utils/" — constraints produce better code. 7. **Iterate, don't restart** — If my first answer is 80% right, tell me what's wrong rather than rephrasing from scratch. I learn from corrections within the conversation. 8. **Let me run things** — I can execute commands, run tests, and check errors. This feedback loop catches mistakes I'd otherwise miss. 9. **Don't over-explain obvious things** — I already know TypeScript, React, common patterns, etc. Spend your words on what's unique to *your* project (business logic, conventions, edge cases).

How I used Claude Code (and Codex) for adversarial review to build my security-first agent gateway

Long-time lurker first time posting. Hey everyone! So earlier this year, I got pulled into the OpenClaw hype. WHAT?! A local agent that drives your tools, reads your mail, writes files for you? The demos seemed genuinely incredible, people were posting non-stop about it, and I wanted in. I had been working on this problem since last year and was genuinely excited to see that someone had actually solved it. Then around February, Summer Yue, Meta's director of alignment for Superintelligence Labs, posted that her agent had deleted over 200 emails from her inbox. YIKES. She'd told it: "Check this inbox too and suggest what you would archive or delete, don't action until I tell you to." When she pointed it at her real inbox, the volume of data triggered context window compaction, and during that compaction the agent "lost" her original safety instruction. She had to physically run to her computer and kill the process to stop it. That should literally NEVER be the case with any software ever. This is a person whose actual job is AI alignment, at Meta's superintelligence lab, who could not stop an agent from deleting her email. The agent's own memory management quietly summarized away the "don't act without permission" instruction, treated the task as authorized, and started speed-running deletions. She had to kill the host process. That's when I sort of went down the rabbit hole, not because Yue did anything wrong, but because the failure mode was actually architectural and I knew that in my gut. Guess what I found? Yep. Tons more instances of this sort of thing happening. Over and over. Why? Because the safety constraint was just a prompt. It's obvious, isn't it? It's LLM 101. Prompts can be summarized away. Prompts can be misread. Prompts are fucking NOT a security boundary. And yet every agent framework I have ever seen seems to be treating them as one. I went and read the OpenClaw source code, which I should have done to begin with. What I found was a pattern I think a lot of agent frameworks have fallen into: \- Tool names sit in the model context, so the model can guess or forge them \- "Dangerous mode" is one config flag away from default \- Memory management has no concept of instruction priority \- The audit story is mostly "the model thought it should" I went looking for a security-first alternative I could trust, anything that was really being talked about or at a bare minimum attempted to address the security concerns I had. I couldn't find one. So I made it myself. CrabMeat is what came out of that, what I WANTED to exist. v0.1.0 dropped yesterday. Apache 2.0. WebSocket gateway for agentic LLM workloads. One design thesis: The LLM never holds the security boundary. **What that means in code:** **Capability ID indirection.** The model doesn't see real tool names. It sees per-session HMAC-derived opaque IDs (cap\_a4f9e2b71c83). It can't guess or forge a tool name because it doesn't know any tool names. **Effect classes.** Every tool declares a class (read, write, exec, network). Every agent declares which classes it can use. The check is a pure function with no runtime state, easy to test exhaustively, hard to bypass. **IRONCLAD\_CONTEXT.** Critical safety instructions are pinned to the top of the context window and explicitly marked as non-compactable. The Yue failure mode, compaction silently stripping the safety constraint, cannot happen by construction. The compactor literally cannot touch them. **Tamper-evident audit chain.** Every tool call, every privileged operation, every scheduler run enters the same SHA-256 hash-chained log. If something happens, you can prove what happened. If the chain is tampered with, you can prove that too. **Streaming output leak filter.** Secrets are caught mid-stream across token boundaries, capability IDs, API keys, JWTs, PEM blocks redacted before they reach the client. **No YOLO mode.** There is no global "trust the LLM with everything" switch. There never will be. Expanded reach comes through named scoped roots that are explicit, audit-logged, and bounded. The README has 15 'always-on' protections in a table. None of them can be turned off by config, because these things being toggleable is how the ecosystem ended up where it is. I decided to make sure that this wasn't just a 'trend hopping' project and aligned with my own personal values as well. I built this to be secure and local-first by default. Configured for Ollama / LM Studio / vLLM out of the box. Anthropic and OpenAI work too but require explicit configuration. There is no "happy path" that silently ships your prompts to a cloud endpoint. I decided that FIRST it needed to only run as an email agent with a CLI. Bidirectional IMAP + SMTP with allowlisted senders, threading preserved, attachments handled. This is the use case that bit Yue and a lot of other people, and I wanted to prove it could be done with real boundaries. I added in 30+ built-in t

Solo indie game developer, new grad no formal SWE experience in love with how productive Claude has made me

My game has gone through a few iterations at this point, but Claude, specifically Claude Code has been game changing for me. Started in the desktop app with 3.5 haiku, now on the max plan with Claude Code. I'm interested to hear from other recent college grads that have built something with these new coding tools. I don't know how much of my project I should attribute to Claude Code, my education, my sheer persistence, or all of the above. Not saying my game is bullet proof BY ANY MEANS, but it's WAY more than I would've ever been able to build without CC. Basically 100% of the code has been written with Claude Code, or copying and pasting over from Claude's desktop app before Claude Code was a thing. Some highlights of what Claude helped me out with: \- No wasting time reading syntax docs for libraries, understand what libraries function is -> implement \- Real-time multiplayer up to 10 players per lobby \- Cost-optimized serverless GPU autoscaling (minimizing GPU costs) \- Mobile first phone as controller UX like Jackbox, or Kahoot \-Mobile browser socket connection troubleshooting \-R2 bucket policy deletes prompts and images daily \-Open source image model, presented cold start challenges 6 months ago I was a new grad with no SWE experience. Today I'm running [https://imageclash.net](https://imageclash.net). It's real-time multiplayer party game focused on creative, comedic, AI image generation in a competitive format (think Cards against humanity with AI images). Players create prompts → AI generates images → everyone votes on the funniest ones. Just wanted to share because Claude Code is genuinely incredible for solo builders with limited experience. This project would have been impossible for me on my own, and it has always been my dream to build games

Heren Godot MCP — Fast, powerful, simple. (+Benchmarks!)

There are already a few great MCP servers that connect AI assistants to the Godot engine. Heren takes a different path: instead of starting a fresh Godot process for every request, it keeps a lightweight WebSocket daemon running in the background. Once launched, the engine stays alive and responsive, so the AI can interact with your project almost instantly! This seemingly small shift makes a HUGE difference in practice: · Operations complete in around 20ms rather than waiting for a full engine cold start. · Because Godot remains alive, sub‑resources like collision shapes, materials, and environments are fully persisted in your scene files – something that’s tricky to get right with ephemeral processes. · Signal connections, batch operations, and script editing all feel smooth and consistent, without the “stop‑and‑go” rhythm of launching and quitting the engine repeatedly. · A built‑in debug system gives the AI access to breakpoints, stack traces, watch variables, and console output, so it can help you troubleshoot in real time. · GPU‑accelerated screenshots let the AI literally see the viewport and real-time coordinates, which is incredibly handy for visual feedback. · The daemon shuts itself down automatically after three minutes of inactivity, so it’s gentle on resources. All of this is built through 15 carefully designed tools that cover scene management, nodes, resources, scripts, shaders, animations, validation, and debugging. The project is open source, completely free, and bilingual (English/Spanish). They said "here be dragons", because they were afraid of their power! 🐉

I built a sidebar for Claude Code: every prompt clickable, jumps the terminal back to that turn

**The why**: I run Claude Code in a tmux session on a Linux dev box, SSH'd in from a Windows laptop. The terminal-only flow worked, but I wanted three things tmux alone doesn't give me — clickable prompt history, a file panel next to the terminal so I stop `cat`\-ing things to look at them, and push notifications when Claude is waiting for me without staring at the tab. Existing tools each solve one slice (`ttyd` = terminal only, `filebrowser` = files only, `code-server` is VS Code-shaped and heavy). I wanted them in one page, on every device. Started as a weekend project, ended up as my daily driver. **What it is**: a single Go binary on your dev box. SSH-tunnel into `127.0.0.1:8080`: * xterm.js terminal, tmux-backed (survives disconnects, sleeps, server restarts) * File tree (preview, drag-drop upload, follows your `cd` via tmux's `pane_current_path` — no shell integration needed) * **Activity panel** reads `~/.claude/projects/*.jsonl` and shows every prompt. Click one → terminal scrolls back to that turn. Same for * Top-bar chips for active model + latest context tokens * Push notifications via Claude Code's `Stop` hook (laptop pings when Claude is idle, even with tab backgrounded) **Design decisions worth sharing**: 1. *tmux is the durability layer.* Every session is `tmux new-session -A -s {id}`. Shell survives WS disconnect, server restart, idle timeout because tmux already solved that. roost owns the WebSocket bridge and an append-only disk log — that's it. 2. *Single-user-per-instance, forever.* I refuse to add accounts/RBAC. Two people share a host? Each runs their own `roost serve` on a different port. UNIX UIDs handle isolation. Multi-tenant logic belongs in a reverse-proxy, not the binary. Kept the auth code under 100 lines. 3. *Vanilla JS, no build step.* Frontend is plain `<script>` files under `//go:embed all:web`. No bundler. Easier to debug, easier to ship, lower future cost. **One bug worth flagging**: tmux's `display-message -p '#{x}\x1f#{y}'` returns 0x1f as literal `_` when tmux is launched without a UTF-8 locale (systemd / launchd units, for example). Burned an hour on this before realising `tmux -u` is the one-line fix. If you ever pipe tmux through field separators, lock the locale. **Validated combo right now**: Linux server + Windows Chrome over SSH tunnel. macOS-as-server works but has rough edges. Codex sessions work too if you swap agents. * Repo + GIF demo: [https://github.com/liamsysmind/roost](https://github.com/liamsysmind/roost) * v0.1.0 tarballs: [https://github.com/liamsysmind/roost/releases/tag/v0.1.0](https://github.com/liamsysmind/roost/releases/tag/v0.1.0) If you drive Claude Code over SSH — what's missing for you?

I tested GPT-5.5 Codex against Opus 4.7 Claude Code, and it's about time Anthropic bros take pricing seriously.

I've used Claude Code the most among AI coding agents. Sonnet, Opus, I've run them all. The reason is simple: they're beasts at tool execution and prompt following. That's also why Anthropic dominates API revenue from code agents. First-mover advantage is real, and developers love them. But GPT-5.5 Codex has been insanely good. When new models drop, I run real tests, not benchmarks. This time I built two tasks: Test 1: PR triage bot – GitHub MCP, scoring formula, Slack alerts, retries, strict TS, no "any". Test 2: Real-time code review UI – React, WebSockets, optimistic rollback, virtualized diff, WS reconnect. Same prompts. Same MCP (GitHub + Slack). Same machine. Here's what I found out: Claude Code (Opus 4.7): \- Verified MCP before writing a line \- Built 36 files in 12 minutes \- Wrote its own WebSocket smoke test (3ms broadcast) \- Zero errors first run \- Total cost: \~$2.50 Codex (GPT-5.5 via Cursor): \- Failed Task 1 (GitHub MCP not reachable – Cursor environment issue, not model) \- Task 2 shipped but needed a patch for infinite React loop \- 28 files, more compact architecture \- Total cost: \~$2.04 (18% cheaper) Claude shipped cleaner. Codex needed a patch pass. For complex, architecture-heavy work, I still reach for Opus – no question. But Codex was leaner, cheaper, and open source. For tight, self-contained tasks where you want to ship fast – Codex holds its own. I'm not switching. But for the first time, I'm watching the pricing gap. Full breakdown with all code, prompts, run logs, and cost tables: [https://composio.dev/content/claude-code-vs-openai-codex](https://composio.dev/content/claude-code-vs-openai-codex)

RT @SocketSecurity: 🐘 @packagist is urging #PHP projects to update Composer after a GitHub token format change caused some GitHub Actions t…

RT @SocketSecurity: 🐘 @packagist is urging #PHP projects to update Composer after a GitHub token format change caused some GitHub Actions t…

I spent much of this year in the hospital with my mom. I built this so I could keep iterating on my more automated workflows while my dev machine was at home.

Wanted to share my mobile claude/codex session tool: Chroxy. **TL;DR Chroxy** is a (yet another!) self-hosted remote client for Claude Code. You run a small daemon on your dev machine, scan a QR code with the app. Then you have access to your terminal sessions and a clean chat view that renders Claude's output as readable messages. Everything goes over a Cloudflare tunnel so there's no port forwarding or VPN setup. Originally, I'd be sitting in a hospital room for hours and come back to my laptop just to find Claude sitting at "Ready to start?" the whole window wasted. I needed a way to stay in the loop, approve a permission prompt, or kick off the next task without physically moving to my machine. The Anthropic billing changes in June are going to steal some of the benefits away from the app... I'm aware that makes it less accessible for some people, and I thought about that before deciding to release it anyway. Honestly, it's been useful enough to me that I'm willing to make that trade. If you're already on API billing it won't change anything for you. **Why not /remote-control?** When Anthropic launched the rc feature, I stopped development and spent some time with it. It was underwhelming to me (Maybe user error). So, I came back and kept refining this. **The stack** * **Server:** Node.js 22, ES modules, runs Claude via the Agent SDK (in-process) or the legacy CLI. WebSocket protocol with Zod-validated message types. * **Mobile app:** React Native + Expo, TypeScript, xterm.js terminal emulation in a WebView, Zustand for state, native speech-to-text * **Desktop:** Tauri tray app wrapping the web dashboard * **Security:** E2E encrypted — X25519 key exchange, XSalsa20-Poly1305. The tunnel sees ciphertext only. * **Other bits:** pluggable provider system (Claude, Gemini, Codex all work with the same app), Docker container isolation for sessions, permission rule engine, git worktree support I built it because I needed it, it let me play with tools I find genuinely interesting, and it feels like a waste to keep it private. If you're into LLM tooling or just want a self-hosted way to run Claude Code remotely, maybe it's useful to you too. My mom passed away in March. I'm sharing this partly because building it kept me sane during the months in the hospital thinking she'd be fine, and I think it might be useful to other people. Repo is [blamechris/chroxy](https://github.com/blamechris/chroxy). There are many like my project, but this one is mine. :')

Claude Code vs Codex: 36 files vs 28, $2.50 vs $2.04, and one infinite loop. My full breakdown.

I've been using Claude Code for months. It's been solid. But with Opus 4.7 and GPT-5.5 both dropping in April, I wanted to see how Codex actually compares on real problems, not benchmarks. https://preview.redd.it/fkwjy5eg3y0h1.png?width=1540&format=png&auto=webp&s=e1df6e53f1164a6da0deabaafe53118cb01b171e Been meaning to do this for a while. Sick of seeing benchmark screenshots, so I just built stuff. So I built two tasks. Same prompts. Same MCP setup (GitHub + Slack). Same machine. Task 1: PR triage bot Read open PRs, score by complexity (files ×2, lines/10, +3 for no labels, +5 for no reviewers), write a markdown report, post Slack alerts for high scores. Required retries, error logging, strict TypeScript, no "any". Task 2: Real-time code review UI React + TypeScript, WebSockets, inline comment threads, optimistic updates with rollback, virtualized diff viewer, WS reconnect with exponential backoff. No UI libraries. Build from scratch. What Claude Code did: - Ran `/mcp` to verify tools before writing a line - Built 36 files in 12 minutes - Wrote an unprompted two-client WebSocket smoke test (broadcast: 3ms) - Zero "any", passed typecheck first try - UI worked immediately What Codex (via Cursor) did: - Failed Task 1: GitHub MCP wasn't reachable through Cursor's execution path. Handled it cleanly though: retried 3 times, logged errors, didn't crash. - Task 2 shipped a working UI in ~15 min, smoke test passed at 5ms - Hit TypeScript errors on first compile and an infinite React loop (useEffect calling hydrate repeatedly). Needed a ref guard patch. - 28 files, more compact architecture Cost (estimated, both tasks): - Claude: ~$2.50 - Codex: ~$2.04 About 18-23% difference. Not massive, but real. What I actually think: Neither agent "won". They're built for different things. Claude feels like pairing with someone who verifies everything before touching the keyboard. Codex feels like a senior dev who wants to ship and move on. What surprised me: no "any" leaks, no hallucinated tool names, both got WebSocket broadcast under 10ms. Six months ago that wasn't a given. submitted by /u/geekeek123 [link] [comments]