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.

OpenAI just dissolved the Codex app into ChatGPT and devs woke up to an editor they never asked for. A tool on someone else's roadmap gets rebranded or killed on a Tuesday. One that runs on your machine can't. That's not a feature, it's the whole reason I build the way I do.

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.

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

Your Mac's agents, in your pocket. Start a terminal from the couch, watch the agent work live, kill it before it ships something dumb. Not a cloud IDE, a remote for the Mac already under your desk. Off to App Store review today.

Fable 5 is here. Time to point Línea at it and see if the hype holds up.

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

running a bunch of agents at once, tabs stacking, context gone, no clue what each one changed. got tired of guessing, so i built my own terminal for it 👇