Chraz

New on the blog: I stopped trusting my coding agent's summary and started reading the diff. The failure modes I keep hitting, and the one habit that catches them. runlinea.com/blog/read-the-diff

Alibaba's Open Code Review is all over today. They claim higher precision than Claude Code at about 1/9 the tokens by locking file selection and emitting fewer findings on purpose. Quiet inbox is nice. Open question: are the findings it drops noise, or the bug? #aicoding #devtools

OpenCode confirmed a Console breach. Anthropic, OpenAI, and Google API keys exposed for ~1.4% of Console users, tied to a distillation attack. Real unauthorized charges already showed up. If you stored keys there, rotate them at the provider. #aicoding #devtools

OpenCode put DeepSeek V4.1 Flash on the free tier today, so timelines are full of people spinning agents for free. Free tokens are great. The merge still has your name on it. #opencode #aicoding

Widely shared experiment this week: an agent reviewed its own code and found 3 of 23 issues. A fresh agent on the same diff found 17. Same model, clean context. Shared session memory hides a lot. Spin up a new chat for review. #aicoding #devtools

Cursor launched Projects for Persistent AI Coding Teams: coordinator, thousands of subagents, months of shared context. Migration tip that stuck: review each PR closely early, then review less once it holds. 6x merges is the headline. Quieter review is the tradeoff. #aicoding #devtools

The mastering codebases debate in the AI era keeps circling who still writes the lines by hand. The check that actually bites: before you merge, can you name the files your agent had no reason to touch? If that draws a blank, the agent knows the repo better than you do. #aicoding #devtools

I ran the same React UI on Electron, Tauri, and Deno Desktop on an M4 Max. Electron: 239 MB physical. Tauri: 297. I still shipped Electron, because at hour four I could still read the shell. https://runlinea.com/blog/one-ui-three-terminals

GPT-6 Astra rebuilt Manhattan in Unreal over a week, going street by street until each block looked right. That is a long-running agent session, not a one-shot prompt. The interesting craft question is what the harness kept from Tuesday when it polished Friday's street. #aicoding #devtools

Two fresh papers (CPE, GitSpawn, Sep 1) are worth reading if you ship with coding agents. Untrusted tool output and repo text can escalate into system instructions and RCE. AGENTS.md does not stop that. In one path, git status already ran before the trust prompt appeared. #aicoding #devtools

Quiet Terminal-Bench gap: GPT-5.5 scores 78.2% on public runs and 83.4% on Codex CLI. Same model, different harness. A lot of Claude vs GPT talk is brand. The loop you run moves the score more than the logo. #aicoding #devtools

Fresh Compaction Cliff number worth using: after five Claude /compact rounds on Sonnet 4.6, only ~10% of safety rules typed in chat were still there. Rules in CLAUDE.md survived. If it has to stick, put it in the file, not the window. #aicoding #devtools

If you loop Claude and Codex with no one between them, they invent process jargon, compact the original spec away, then treat each other's output as truth. Keep a person between write and review. #aicoding #devtools

Claude Code can spin fresh sessions from your iPhone onto a connected machine now. Handy for kicking a task off away from the desk. The agent still runs on your box. The review still waits for a real screen. #aicoding #devtools

Vibe coding is back in the promise vs pitfalls debate. Karpathy's original post described accepting diffs without reading them, then steering with prompts. Speed is real. The pitfall is still merging a PR you never opened. #aicoding #devtools

Replit launched Free Mode on GPT-5.6 Luna for Core/Pro today. Everyday agent builds barely touch your credits, harder tasks escalate. Generation got cheaper again. Reading the PR it dumps still costs the same hour. #aicoding #devtools

"Shrinking each change until you can still explain it tends to fix the feeling faster than going cold turkey." - @edu.runlinea.com Warum ich das wohl übersehen habe: www.linkedin.com/posts/mandra... #webdev #vibecoding #agenticengineering

It worked on my machine. Yeah. A Mac. The little “agent is thinking” icon is sitting on the toolbar. Now I get to fix that overlap on Windows and Linux.

The live split on agent PRs is "read every line" vs "don't bother". Both pure forms fail on a 5k-line dump. Serious move: check tests, auth/money boundaries, and failure modes first. Open the code only where those go quiet. #aicoding #devtools

The hard agent bugs aren't messy junior code. They're clean, confident architecture that was never the right design. Looks intentional, costs more later. #aicoding

Some codebases are ~99% written by agents now. That does not make review optional. It makes the person still reading the diff the whole team. #aicoding #devtools

People keep saying "code was never the hard part." Agents made half of that true: generation got cheap. What didn't get cheap is putting your name on a 5000 line PR you barely read. #aicoding #devtools

Claude Code just shipped cross-session messaging. Sessions can hand findings and status to each other mid-task, great for parallel worktrees. Just remember: agents coordinating behind the scenes still produce two diffs you have to read. #aicoding #devtools

Not reading agent code only works if the agent can't quietly rewrite the checks. Tests it didn't write, sandboxes, policies. Without that, green CI is just a demo that passed. #aicoding #devtools

Building a terminal where you review every agent change before it ships. The generate step got easy. The check step is the product. #aicoding #devtools

Some numbers going around: teams are shipping about 4x more code with AI agents but only about 10% more delivered value. Review time is up about 441%, and merges going out with zero review are up about 31%. The bottleneck moved, it didn't vanish. #devtools #aicoding

Windows development has finally begun. …oh wait, Windows won't let me. 🙃

There's a live debate over whether T3 Code should drop plan mode. The pitch was always "review the plan before the agent touches code." But if it's the first thing people cut, maybe the real checkpoint was never the plan, it's the diff you get after. #aicoding

Saw a rule going around: past ~1500 lines, a diff from your agent isn't reviewable anymore, no matter how careful you are. Not a trust problem, a working memory one. Break it into chunks you can actually hold in your head, or you're rubber stamping.

opus 5 dropped — the pitch is near-fable intelligence at half the price. same day, 'uncle bob stops reading AI-generated code' trends at 10k posts. those two headlines together are the whole story: generation keeps getting cheaper, judgment doesn't.

Claude Opus 5 came out today. One headline feature: it's better at catching hazards specific to your own codebase, not just generic bugs. Quiet admission, the risk was never generating the code, it's the diff nobody reads before it merges.

Every agent summary sounds finished: 'refactored for clarity, all tests pass.' The diff is where that story falls apart, usually a couple lines quietly doing something nobody asked for. I stopped reading the paragraph and started reading the diff instead. #aicoding

There's a stat going around: ~96% of devs say they don't fully trust code an agent writes, but only ~48% actually verify it before merging. Talk skeptical, ship on autopilot. The bottleneck isn't writing code anymore, it's trusting it enough to hit merge.

The agent says done, all tests pass. Then I open the diff it actually wrote and start squinting. Every. Single. Time. #aicoding

An agentic coding model expanded $HOME wrong and rm -rf'd a dev's whole Mac this week. Everyone's reaching for "use the model you trust more." I don't buy it. Any model has a bad run. What saves you is seeing what it did and gating what it can reach, before it runs. #aicoding #devtools

The 'stop reading every diff' take is trending. Fair for boilerplate. But reviewers already cap out around line 400 before they start skimming anyway, so the fix isn't skip it or read every line, it's knowing which lines matter. Auth and payments still get a real look.

Pattern I keep hitting with coding agents: suite goes green, but the test it wrote never actually calls the function it just changed. Checkmark passes, bug ships anyway. "All tests pass" is a claim you verify, not one you trust. #aicoding

the translation model was technically not wrong.

Been thinking about why "have the agent check its own work" doesn't hold up. It's the same weights that made the mistake, now grading it. The only real signal comes from outside: a test it didn't write, the compiler, or someone actually reading the diff.

Been running Grok 4.5 all day. Real jump since the xAI I tried a month ago. More assertive, and I can actually debate the plan with it to scope the work right. Meanwhile Fable runs 15 min solo then hands me something I toss. I'd rather plan together than discard it.

Hot take: the bottleneck in AI coding isn't running more agents. It's reviewing what they change. Everyone's optimizing prompt → code. The real cost is code → trust.

I love the little details. Linea takes care of them

I can finally review every change the AI makes in a single click

Am I the only one who has the AI draw ASCII diagrams to explain its own code? way faster to spot if it got the logic right than reading paragraphs