Upload2Shell (CVE-2026-125396) is worth reading even if you've never typed `gs` in your life.
Someone uploads a ".jpg". Your image pipeline hands it to ImageMagick, ImageMagick decides it's really something Ghostscript should render, and Ghostscript runs PostScript. A use-after-free in its font loader gets past -dSAFER, and now there's a shell running as your rendering process.
What I take from it as a backend dev: every "just make a thumbnail" call is an interpreter running untrusted input. Treat it like one:
- run conversions in a throwaway sandbox with no network and no secrets
- allowlist formats in your ImageMagick policy instead of trusting extensions
- actually know which binaries your preview pipeline shells out to
Fix: Ghostscript 10.08.0 or your distro's backport.
@miramurati interesting tradeoff. looping moves the thinking from visible tokens into repeated passes, so "just read the CoT" gets weaker as a monitoring tool the more you loop. nice that the variable-loop model is out so people can study exactly that
GPT-6.2 Astra is a good example of why I treat model upgrades like dependency upgrades.
Per Arena's Agent index vs GPT-6 Astra: coding +50, chat −54. Overall it moved up one spot because the two shifts nearly cancel out.
So "is the new model better?" doesn't have one answer. Better at the thing you actually call it for?
Before switching anything in prod:
- pin the exact model version, don't float on an alias
- keep a small eval set built from your real traffic, not leaderboard tasks
- diff old vs new outputs on that set and actually read the failures
- roll it out behind a flag, one use case at a time
A leaderboard average describes the average user. Your workload isn't average.
Seeing a lot of "AI lets me rebuild any SaaS in an afternoon, so I self-host everything now" takes.
As a backend engineer: writing the service was never the expensive part.
The expensive part is everything after it ships: backups you've actually tested restoring, upgrades across breaking versions, patching when a CVE drops on a Saturday, and being the one who gets paged.
AI made the first 10% nearly free. The other 90% is still yours.
Self-host the stuff where owning the data really matters to you. For the rest, the subscription is mostly paying someone else to carry the pager.
@PatchOnChain each worktree gets its own index under .git/worktrees/<name>/, so torn index.locks usually means some agent ran git from the main checkout instead of its own. pinning cwd per agent and refusing any git command that resolves to the main repo catches most of it
@ChiragLeuva this. read scope gets way less attention than write scope, but a stale doc it trusted does more damage than a write you'd have caught in review
@arpit_bhayani agents are great at writing the script though. let it write it once, read it yourself, then run the boring deterministic thing forever for free
@addyosmani nice that every call inside the script still goes through the deny/ask rules and PreToolUse hooks. curious what happens when one of them hits an ask mid-script though. does the whole script pause and wait, or does that call fail and the script deals with it?
An NBER paper this week tracked 500k+ GitHub developers before and after they picked up AI coding tools.
Autonomous agents: commits +240%. Projects +80%. Actual releases: +30%. And across four big app marketplaces, way more new apps, but no increase in total usage.
From the backend side this doesn't surprise me. Commits were never the scarce thing. The scarce things are review, rollout, someone on call when it breaks at 3am, and a user who actually needs it. None of those got 3x faster.
The paper calls it the weak link: the chain moves at the speed of its slowest human step.
So the tools I'd bet on next aren't the ones that write more code. They're the ones that make everything after the commit cheaper: review, testing, release, ops.
What's the weak link for you right now?
https://t.co/1zXA3ZShPn
@Shay_Slay_ that's the worst direction to regress in for agent work. a model that fails loudly is annoying, one that says done on a blocked task means you now have to check every run. I'd rather it just stop and ask
@Agline_in yeah the ask list is the underrated part. most people only think allow vs deny, but forcing a prompt on deploys and side-effect MCP tools is what makes it safe to pre-approve everything else
The swarm talk this week is about how many agents you can run overnight. The part that still feels unsolved is the permission prompt.
A November survey of 203 developers who use coding agents found that 61% of the people who carefully review most or all of the generated code still often approve at least one kind of agent action without looking closely. Shell commands, network calls, connected tools. Things that can have effects you will never see in the PR.
We got serious about reviewing the diff. The yes/no dialog is still the part that disappears.
A swarm doesn't fix that. It just gives you more of those prompts, or skips them.
Curious how other people actually handle the approval step. Do you read it, or has it become muscle memory?
@Mudit__Gupta makes sense that mixing wins, different models have different blind spots so two cheap passes overlap less. curious about false positives though, 19/26 means a lot less if it came with 40 nitpicks
@stretchcloud the "no earlier findings carried over" bit is the underrated part imo. once a reviewer sees what the last pass flagged, it tends to just re-check those and stop looking