The marketing ploys of OpenAI/Anthropic where agents build something that nobody uses might be hard to track given that there are zero users. But what about everyone using agents for real software? It's trivial to prove that agents make progress.

It's actually kinda pleasant, especially when I consider all the tickets I'm not excited about doing. It's prob worth focusing on that aspect of it.

Eliminating Down syndrome and cystic fibrosis, for example, seems not only reasonable but a moral imperative.

Fable 5 is 2x the cost per token of Opus 4.8, and it's much less work to review a plan than generate one.

It's very easy to demand or promote sacrifices you expect other people to make. But I don't find that to be very empathetic.

I've already seen how society is when we shame and hand-wring about the personal decisions others make, and it's not one I want for my kids. At some point you need to be satisfied with your own decisions and then let other people make theirs.

Fable 5 has been a major improvement in high-level reasoning, like taking a plan file that has been optimized to the point where neither Opus nor Codex can find anything to change about it (neither in direction nor impl-detail), and Fable 5 will find high-level directional simplifications and pivots, or it will consider the best pivots itself and explain why it rejected them in favor of the plan's direction.

It's so expensive though. A single review of a plan file with Fable 5 (xhigh effort) will use 2-3% of my hourly limit on a $200/mo plan.

I think my new workflow is to generate the initial plan with Opus 4.8 (max effort), get Fable 5 (xhigh) to review it for directional feedback, then start the Opus<->Codex revision loop from there.

Pho is a pretty bad source of fiber.

It sucks that we're skipping over such good tools like cronometer.com to figure out what we're actually eating and going straight to hallucination, adding more confusion to nutrition.

So much so that I vibe-coded my own terminal emulator for vertical tabs on macOS (using libghostty for the terminals) that is faster and less weird than iTerm.

It breaks our ape brain intuition that anything good must also be bad. But consider all the food tech you take for granted while singling out zero-cal sweeteners.

Deep research in the codebase, deciding on the flavor of code to write that matches the project, deciding how you'll model the feature with types, how to architect it so that it's testable, writing the tests, foreseeing cases beyond the obvious path, etc.

What changed is that it can be automated. Or, just grant a world where AI is perfect at implementation.

Now our time/energy/attention is freed up to concentrate the work around planning what to build. And the interesting part is that it becomes the input into the AI implementor.

This is a good thing since we tended to skip the planning stage since it's hard in its own way. Or we start building something and then try to synthesize a high level direction from it, yet now since refactoring is so expensive, we're committed to a solution.

AI just makes it so obvious how bad of a process it is that we can't ignore it anymore, and now we need to finally figure out good processes.

Even little stuff like: I've created issues on the Claude Code github that got agreement and then led to code changes. Why isn't there a default, built-in way for my issues to rise above the zero-effort chaff? If you finally do the work of vetting someone's PR, why isn't there a built-in (hidden) way to +1 someone so we can see that they have some reputation with the project on their future issues/PRs?

What do you mean you just spent a week implementing something in secret?

AI makes it extra silly because now you can craft up your unsolicited code change in minutes, making it extra obvious that code changes should spawn from real discussion and agreement.

TFA is part of looking for new processes that actually work. Dunno why people are having such rose tinted glasses about pull requests. Open an issue, talk to people. Have an idea? Then get people to cosign it.

I see all projects moving this direction. Makes more sense to hash out a plan together.

And if you put the review effort into polishing an impl plan, then it doesn't matter which model implements it either.

If you use AI, then AI must be expected to solve all problems, even problems that affect everyone like infra scaling.

And if perfection isn’t delivered, then of course it wasn’t: you used AI and AI sucks.