You Are "Recursive Self-Improvement" (Sunday Builder's Mindset)
Darwin didn’t invent “survival of the fittest.”
Herbert Spencer did. Darwin borrowed it — and never seemed fully comfortable with it.
Not strongest. Not fastest. Not biggest.
Most fitted. Shaped to the problem actually in front of it.
The finches didn’t win by being better finches. Each one got fitted to its island — its food, its constraints, its particular problem. Fitness was never a trophy. It was a relationship between an organism and exactly where it stood.
Hold that thought.
Anthropic reported this week that Claude now writes more than 80% of the code in its own codebase. Low single digits a year ago. Eighty percent now. They’re calling it an early signal of recursive self-improvement — each version helping shape the next.
I can’t stop thinking about it as a mirror.
Because the model isn’t getting better by trying harder. It’s getting better because its output becomes its input. The loop is the unit of improvement — not the effort.
And I think most of us have the loop backwards.
Lesson one: the loop compounds, the effort doesn’t.
I used to measure a week by how much I did. The model measures by how much of what it did made the next round easier. Those are not the same metric. Reading a paper isn’t improvement. Reading it in a way that changes how I read the next one is. Most of my “productive” weeks generated zero recursion. Just output, dropped on the floor.
Lesson two: it started at low single digits.
The 80% number is the headline. The part that should humble us is where it started — unimpressive, easy to dismiss, not worth a press release. Compounding always looks like nothing right up until it looks like everything. The version of me that’s barely competent at something new isn’t behind. It’s at the low-single-digit stage of a curve, if I keep the loop running.
Lesson three: speeding up one thing just moves the bottleneck.
Here’s the line from the paper I keep returning to. Claude got so fast that human review became the new constraint — people can’t check the code as fast as the model writes it. Solve one bottleneck, the constraint relocates. It never disappears.
For me the bottleneck was never doing more. I can generate experience far faster than I can metabolize it. The thing throttling my own improvement isn’t output — it’s review. Reflection is the rate limiter. I was flooring the gas pedal on the one part that was already fast.
Lesson four: the gains are on the open-ended problems.
The model’s biggest jumps weren’t on the easy, well-defined tasks — it was already good at those. The steep climb was on the messy, no-right-answer problems. Same for us. The clean, scriptable parts of clinical work are where I feel competent and where I learn nothing. The ambiguous ones — the unclear disposition, the hard conversation, the governance call with no precedent — those are the only places the curve is actually still moving.
So here’s the difference that matters.
The model recurses blindly. It just runs the loop. It has no say in what it becomes.
You’re not blind. You get to choose what feeds the loop — which problems, which feedback, which version of yourself you’re building toward. The model improves at everything. You can improve on purpose, toward the niche only you stand in.
That’s the whole edge. Not more compute. Intent.
The organism that survives isn’t the strongest. It’s the one still adapting — deliberately, toward the problem actually in front of it.
So the question I’m sitting with this week isn’t “what did I build.”
It’s: what did I do that made the next version of me easier to build?
How are you recursively improving?
Tell me how you are recursively improving (kevin@clinicians.build) — I read every one.
— Kevin