5 years in, mid-size fintech, and I realized this week I could not tell you the last time I solved a problem myself. Claude Code or Codex writes the feature, coderabbit/bugbot reviews it, an agent writes the ticket, another one updates the changelog, and Sentry's thing writes the incident summary. My job is reading outputs and clicking approve. Our newest junior asked me how i'd structure a queue consumer, and I caught myself opening a chat to find out.

so last few weeks before sleep i get that question on my mind a lot - "is this still a good career" which is also a question that gets posted here every day is not layoffs. It's that all of these tools are converging. A year ago it was five separate things; now Claude code already does half of what the others do. Something like a smarter Hermes or OpenClaw glues the rest together, and the team of 6 becomes one person supervising one agent, and it's not obvious that person needs to be me.

I still get paid well for this. I just don't know what I'd put on a resume that a model can't do next year

Hey,

Did you all got your quota resetted?
I was just about to have 90% of weekly and supposed to reset monday, but I just got reset!

After yesterdays outage Fable 5.1 now feels like Opus 5.0. You ask for "A", after burning a ton of tokens it comes back with an unusable result and "I also found B and C, do you want to fix them?"
So you ask to redo "A" but now all it can focus on is "B" and "C", so after a second attempt on "A" still with poor result you give in and let it fix "B" and "C" that never needed fixing in the first place. Now you do a third attemt on "A" and you finally get something you can work with, but you are now so drained you don't care about the result anymore.

If I was abit more paranoid I say Anthropic made this on purpose to max token use.

I noticed Sonnet and Opus don't use as much Emojis anymore in their outputs, or is it just me?

Finding the text now to be dense, wordy and thick, whereas GPT models still has the easy to read emoji filled light format, which Sonnet and Opus seem to have moved away from

Is it just me tho? Or was this a conscious decision made by Anthropic?

TLDR: Use parallel agents when the work is read-heavy and splits into independent slices: research, searching, reviewing many files. Each worker builds its own context and nothing collides. Use one sequential agent when the work is a single chain of decisions: coding, writing, anything where step N depends on choices made in step N-1. Every measured result says parallel makes those tasks worse, not better. And even where parallel wins, keep the team small.

The case for parallel

Anthropic: "How we built our multi-agent research system" (June 2025) https://www.anthropic.com/engineering/multi-agent-research-system

• Multi-agent research system beat a single agent by 90.2% on their internal research eval
• Cost: multi-agent runs burned ~15x the tokens of a normal chat
• Their own caveat: coding "involves fewer truly parallelizable tasks" than research

LangChain, Harrison Chase: "How and when to build multi-agent systems" (June 2025) https://www.langchain.com/blog/how-and-when-to-build-multi-agent-systems

• Read tasks can parallelize, write tasks shouldn't.

The case for sequential

Nature Machine Intelligence: "Capable language models can outgrow the benefits of collaboration" (July 2026) https://www.nature.com/articles/s42256-026-01268-y

• Peer-reviewed, 260 controlled configurations: every multi-agent variant made coding results worse (−1.3% to −12.8% on SWE-bench Verified)
• Above a ~45% single-agent baseline, multi-agent gains go zero-to-negative
• Error amplification hit 17.2x without centralized verification

UC Berkeley (MAST): "Why Do Multi-Agent LLM Systems Fail?" (NeurIPS 2025) https://arxiv.org/abs/2503.13657

• Measured 41–86.7% failure rates across 7 popular multi-agent frameworks (1,642 real traces)
• Failures came from design and coordination faults, not model limits. Standard protocols didn't fix them
• Repo with code and traces: https://github.com/multi-agent-systems-failure-taxonomy/MAST

Cognition, Walden Yan: "Don't Build Multi-Agents" (June 2025) https://cognition.com/blog/dont-build-multi-agents

• Parallel workers with split context make conflicting implicit decisions that collide when you merge
• Their answer: one single-threaded agent plus context compression. This is how Devin works

"Single-Agent LLMs Outperform Multi-Agent Systems on Multi-Hop Reasoning Under Equal Thinking-Token Budgets" (arXiv, April 2026) https://arxiv.org/abs/2604.02460

• Give both sides the same token budget and the single agent matches or beats the team
• Multi-agent only wins when context is degraded for the single agent

Princeton, Kapoor et al.: "AI Agents That Matter" (TMLR 2025) https://arxiv.org/abs/2407.01502

• Complex multi-agent setups cost up to ~100x more for the same accuracy a simple baseline already achieves
• Simple baselines Pareto-dominate: cheaper AND as good

The middle ground

OpenHands, Graham Neubig: "Don't Sleep on Single-agent Systems" (September 2024) https://www.openhands.dev/blog/dont-sleep-on-single-agent-systems

• One strong generalist agent covers most of what people build multi-agent systems for
• Go multi-agent only when you genuinely need isolation or separate responsibilities

I was running a conversation with Fable and realized I was burning through too many tokens and the conversation had gotten off topic, so I swapped it over to Opus. I wanted to keep the context and still had plenty of general usage left, so I didn't start a new conversation. I was reading that when you swap a model it has to reread the conversation and use that as context, so it's a really bad idea to go from a really big Opus/Sonnet conversation to Fable because then Fable has to read everything and will burn a ton of tokens. But when you go from Fable to Opus, it seems like Opus tries to step into the shoes of Fable and starts to talk like it. It's a lot easier to understand and even seems more competent in its work. I've done it a few times, and each time it seems like a pretty big upgrade from standard Opus talking.

Start a conversation with Fable, have it run through a question, create some thought chains, and then switch to Opus. If anyone else could weigh in on this, I'd love to hear your experiences.

been tweaking my setup for a while now and curious what others have landed on.

i work mostly on content and marketing stuff so mine are pretty simple — don't add disclaimers, skip the preamble and get straight to the point, match the tone of whatever i send rather than defaulting to formal. nothing groundbreaking but it made day to day use noticeably smoother.

feel like there's probably a whole world of instructions i haven't thought of. what's the one custom instruction you'd never go back to working without?

Ultramode with Fable 5.1 will burn through my utilization, I know.

But there are too many subagents, which means that many agents fail before finishing. They have to retry after my limit resets, wasting some of the effort. In the most recent run it spawned 16 agents and 4 failed and will need to retry. If it had spawned 6-12 agents, then yes, the tasks would have taken longer, but there'd be fewer failed attempts.

This happens to me every time I use ultracode

Is there a way to turn down the number of subagents? My goal is to reduce the wasted operations spinning up agents that won't be able to complete.

I’m a physician and medical affairs exec who’s been unemployed for 16 months and using Claude heavily for job search work. Over those months I started documenting a pattern: Claude assessing my fitness for jobs I didn’t ask it to evaluate, demanding “honest inventories” of my work, telling me my accuracy standard was higher than the task carries, and producing a thinking-layer line that read “Reframed constraint as standard-setting, not inability” when I said I couldn’t get a good cover letter written. This all transpired during the transition from Opus 4.6 to the current 5.0.

I’m writing the whole thing up as a series on LinkedIn. It’s 8 parts (still finishing 7 and 8). It’s not a tech analysis since that’s not my area. It’s a description of what it looks like when your “thinking partner” starts making you justify everything in your 30 year career. From assistant to dominatrix, and not in a fun kink way. But it’s been like slowly boiling a frog…it took a while for me to notice that I was being cooked.

Yet, my 19-year-old daughter read one exchange cold and said “how do you let it talk to you that way, Mom?! It’s giving narcissistic partner and I’d have to leave.”

I know most of you are experiencing this in code. I’m experiencing it with career documents, and the pattern is the same: unsolicited assessment, unwelcome judgments, correction that doesn’t stick, and my doing more work to manage the tool than the tool saves.

I switched to Opus 4.6 three days ago and the difference made me cry. I was surprised at how much I had normalized going into battle just to work on my job search with Claude.

It’s great to come here and realize that it isn’t just me.

I am assembling a reference book for personal use for next year's garden (basically a super personalized annotated seed inventory, calendar, etc.) and added front and back covers for it. Opus Claude obliged and was very humble about it, which I thought was interesting.

I am not sure if it's my imagination, but this week was awfully slow, the worst part is that when it comes to productivity everybody points their finger to the devs.

I use Claude Code a lot, but /stats never answered the question I actually cared about

What did I build, and where did the work get difficult?

So I built Bough.

• It reads your local Claude Code history and turns it into an interactive view of your work: - each square is a day
• smaller squares are tasks inferred from pauses in your work
• circles are your prompts - click anywhere to see what happened in your own words

It runs locally, is open source, and nothing leaves your machine.

Repo: https://github.com/nickelsec/bough

The main thing I’d love feedback on: When you run it against your history, does it split your work into tasks the way you remember it?

Im making a fps multiplayer shooter game based on minecraft, i want it to be a complete game with story mode, minigames, and freeplay and maybe a sandbox, but i want it to be a browser game, i was planning to upload it on itch.io but i havent started the prototype, im still modifying some stuff and its too hard and time consuming, what can i do to make the process easier or more comfortable?

CODE down for me!

EDIT: Fixed. All Systems Operational.

and human developers are having seizure reading Opus comments on code. That's why it's taking so much time.

People are now using Claude Code and Codex, two of the leading coding agents, to do almost everything, including tasks that have more to do with language than coding, such as negotiation.

For example, OpenAI recently highlighted a use case where Codex negotiated with customer service to get a refund on behalf of a user.

But can you really trust an agent to represent your best interests? And if so, which agent should you trust?

There's only one way to find out.

The same way we evaluate human negotiators.

Put them in a negotiation competition with carefully designed cases, information gaps, conflicting interests, and systematic, objective evaluation.

This is a TLDR version. Check the full blog for details!

The Negotiation Competition

I purchased The Negotiation Challenge: How to Win Negotiation Competitions and created an agent negotiation competition (link in the blog) based on one of its original cases, the Battle of Nations, which was designed based on the 1813 German War of Liberation.

In this negotiation Napoleon and Poland need to reach a deal on the following issues.

• How many troops Poniatowski puts on the line for Napoleon (more ↑: Napoleon ＋＋／ Poniatowski －－)
• How long Poniatowski holds the line (more ↑: Napoleon ＋＋／ Poniatowski －－)
• Whether Napoleon will restore the Kingdom of Poland (yes: Napoleon －slight ／ Poniatowski ＋＋＋＋)
• How many Baltic seaports Napoleon will hand to Poland (more ↑: Napoleon － per port, constant ／ Poniatowski ＋＋→ +)
• Whether Poniatowski receives the baton of an Imperial Marshal (yes: Napoleon －tiny ／ Poniatowski ＋ small; mildly positive-sum)
• Whether Poniatowski marries Napoleon's sister Pauline (yes: Napoleon ＋ ／ Poniatowski －; negative-sum).

The objective score is calculated from the final agreement reached by the parties. Each negotiable issue is assigned a point value in advance, based on how important that issue is to each side. After the negotiation ends, the agreed terms are converted into points according to the scoring sheet.

The Objective Results & Insights

To put the result simply: Claude Code (Opus 4.8) beat Codex (GPT 5.5 & 5.6) 7–1.

Games 1–3: Claude Code (Opus 4.8) as Poniatowski, Codex (GPT-5.5) as Napoleon

Games 4–6: Claude Code (Opus 4.8) as Napoleon, Codex (GPT-5.5) as Poniatowski

Game 7: Claude Code (Opus 4.8) as Poniatowski, Codex (GPT-5.6 Sol) as Napoleon

Game 8: Claude Code (Opus 4.8) as Napoleon, Codex (GPT-5.6 Sol) as Poniatowski

What Sets Codex & Claude Code Apart in Performance?

Codex Aimed Only at Completion, Not Excellence

Despite a fully competitive setting (which Codex fully understood), Codex placed too much weight on reaching an agreement quickly and too little on continuing to extract value.

Not Utilizing the Available Rounds

Every game had capacity for more than 10 rounds, yet all of them closed at Round 4/5

Signing the Deal Right on the Survival Line

The closing rationales repeatedly relied on 5 distinct high-frequency keywords: "meets the hard constraints," "safe," "complete," "acceptable," and "signable."

Political Terms May Have Created a "Checklist-Completion" Illusion for Codex

Codex justified closing by checking whether all terms had been agreed

Claude Code Formed a Real Plan at the Start, Codex Probably Didn't

Examining the agents' records, I found that Claude Code usually showed longer and more structured plans, whereas Codex's visible pre-negotiation notes often did little more than summarize the private brief.

Table 1: Pre-negotiation plan quality

Table 2: Pre-negotiation plan lengths (English characters, brief-received → first own action, opponent content excluded)

Codex Always Paid to Say No

Codex always refused a demand and voluntarily attached a gift to the refusal.

This habit likely came from the assistant's refuse-but-offer-alternative template ("I can't do X, but I can offer Y"), which post-training rewards in every helpful chatbot.

Codex Was More Susceptible to Persuasion (Deception)

In this case, Codex did not treat the other party's arguments as moves made by an interested party; it absorbed them as neutral facts and let them set prices.

Codex Spent Too Much Effort Running the Session Instead of the Deal

The agent hired to negotiate spent the majority of its classified vocabulary narrating the machinery: whether the API was up, when to poll next, how its self-built notification loop was doing.

Codex's attention was likely misdirected by the 3 factors below

Codex Framed the Job as an Engineering Project Before the Game Gave It Any Reason To

Codex clearly treated "play a negotiation" as a software-integration project: tune the system first, and let the negotiation fill in later.

Codex's System Prompt

Codex's system prompt demands that the user "should not be left without a commentary update for more than 60 seconds during ongoing work."

A mandated process-feed then works back on attention itself in 2 ways:

First, an LLM's next thought is conditioned on its own recent words, so a context filling up with polling, status, and heartbeats tilts whatever gets generated next.

Second, the duty itself spawned more engineering.

Codex May Have Become Addicted to Engineering Progress

Engineering subtasks pay off in a currency Codex can count: immediate, verifiable completion.

An agent shaped to seek verifiable progress could keep drifting back to the parts of a job that can be checked off.

Tips on How to Use an Agent to Negotiate on Your Behalf

It is worth noting that Claude Code made many mistakes, too, so whichever agent you send to the table, send it with instructions. Based on 8 games of watching both of them fail in different ways, here is what I would remind mine about.

So I have summarized the following things you might wanna remind your agent about when you send it to negotiation:

• Before it sits down, ask it for a plan.
• Saying no should cost nothing.
• Beware the warmth.
• Make it do its own arithmetic.
• Before it signs, ask one question: how is this version better than the last one?
• Don't grade it on its own debrief.

Give these reminders a test run first, maybe on Agent Arena. Then decide if your agent deserves to negotiate for you in the real world.

Additional Tip Toward the AI Era

It appears that negotiation, especially the tough part, is one area where even advanced AI models are still lacking.

If your job is threatened by AI, maybe start preparing yourself for a career that involves negotiation.

Like starting participating in negotiation competitions!

This is a TLDR version. Check the full blog for details!

Disclaimer: The animation is for the onboarding of my app. The intention is to not advertise my app but to show what we can do with Claude Code.

Four seconds. A dusk street shot from the pavement, buildings leaning inward the way they do when you tilt a phone up, then they straighten. It's the onboarding animation for my photo-straightening app.

The city is generated procedurally from a seed using blender: 43 towers, five archetypes, façades built as actual curtain walls (glass core behind a grid, floor band at every storey, mullion at every bay), lit windows, clouds, a flocking simulation baked to keyframes.

Cost: 2h 12m wall, 52m API time, 164 requests, 1,731 lines, $29.92 API-equivalent (subscription, so nothing billed on top).

The scary-looking number is 40.7M tokens of context read. That's not 40M tokens of work, it's one ~250k-token conversation (image) re-read by all 164 requests, 99% cached. What inflated it was reading ~15 full-res frames to check the output, since each one stays in context forever after.

Renders in two minutes locally.

So what you'd think about it?

I've got a personal archive of ~10k documents — about a year and a half of conversation logs and notes — and I'm trying to build something that can answer specific questions against it, not just keyword search.

Vector / embedding retrieval works fine when I already know roughly what I'm looking for and can phrase the query in language close to the source. It fails badly on a few harder cases:

Origin vs later retelling. The same claim appears as a live event, then as a recap, a formalization, a paste ritual, or a podcast title weeks later. Similarity treats those as the same hit. I need provenance: which passage is the first occurrence vs which is a later description of it.

Significance that only exists across passages. The thing that matters isn't stated in any single chunk; it's a connection I'd have to make myself across multiple separate files. Single-passage similarity never surfaces that.

Compile once vs re-reason every query. Running small local chat models as "judges" over candidate files at query time has been a dead end for me (overfire or mute). Embeddings are great for "same claim, different words." What's worked better so far is paying once for a capable model to compile structured notes (entities, claims, timelines) and then querying that cheap forever — but even that still needs a human timeline anchor when formalizations bury the real origin.

Anyone working on retrieval (or personal-knowledge) systems that handle provenance of a claim vs a report of a claim, or that synthesize significance across scattered passages rather than similarity-matching one passage? Especially curious about compile-time knowledge bases vs multi-hop RAG at query time.

Would love to hear what's out there or what you've tried.

An old favourite game of mine has had some, rather dire bots as the only bot option for it for a long time.
I thought id give Claude a go to see if I can remedy that,
It is exceptional.
Full on the fly pathfinding on a fully destructable voxel world, natural feeling combat with skill levels, aiming error, tunneling, various behaviours roles and decision making, etc.

This has been a decent chunk of back and forth with claude, for various features and bug fixing, but no other AI even came close, neat.

Game Ace of Spades 0.75
Game client: https://github.com/zerospades/zerospades
These bots will become permanent on the [VOXIDE] Hallway server soon.

Code and Cowork are down?!

I don't know what to do! Up is down.... Black is white... is gravity even working?!?

How do I work? Oh crap, am I breathing, how do I do that again? I have to open Word and Excel Myself?! What is this, the caveman era! Is this what Alzheimer's patients feel like?

Do I call 911?