"There Will Come Soft Rains" a year from today
Easily my all-time favorite short story is "There Will Come Soft Rains" by Ray Bradbury. (If you haven't read it, just Google it and you'll find a PDF—seemingly half the schools on earth assign it.)
The story takes place exactly a year from now, on August 4th, 2026. In just a few pages, Bradbury recounts the events of the final day of a fully-automated home that somehow survives an apocalyptic nuclear blast, only to continue operating without any surviving inhabitants. Apart from being a cautionary tale, it's genuinely remarkable that—despite being written 75 years ago—it so closely captures many of the aspects of the modern smarthome. When sci-fi authors nail a prediction at any point in the future, people tend to give them a lot of credit, but this guy called his shot by naming the drop-dead date (literally).
I mean, look at this house.
It's got Roombas:
Out of warrens in the wall, tiny robot mice darted. The rooms were a crawl with the small cleaning animals, all rubber and metal. They thudded against chairs, whirling their moustached runners, kneading the rug nap, sucking gently at hidden dust. Then, like mysterious invaders, they popped into their burrows. Their pink electric eyes faded. The house was clean.
It's got smart sprinklers:
The garden sprinklers whirled up in golden founts, filling the soft morning air with scatterings of brightness. The water pelted window panes…
It's got a smart oven:
In the kitchen the breakfast stove gave a hissing sigh and ejected from its warm interior eight pieces of perfectly browned toast, eight eggs sunny side up, sixteen slices of bacon, two coffees, and two cool glasses of milk.
It's got a video doorbell and smart lock:
Until this day, how well the house had kept its peace. How carefully it had inquired, "Who goes there? What's the password?" and, getting no answer from lonely foxes and whining cats, it had shut up its windows and drawn shades in an old-maidenly preoccupation with self-protection which bordered on a mechanical paranoia.
It's got a Chamberlain MyQ subscription, apparently:
Outside, the garage chimed and lifted its door to reveal the waiting car. After a long wait the door swung down again.
It's got bedtime story projectors, for the kids:
The nursery walls glowed.
Animals took shape: yellow giraffes, blue lions, pink antelopes, lilac panthers cavorting in crystal substance. The walls were glass. They looked out upon color and fantasy. Hidden films clocked through well-oiled sprockets, and the walls lived.
It's got one of those auto-filling bath tubs from Japan:
Five o'clock. The bath filled with clear hot water.
Best of all, it's got a robot that knows how to mix a martini:
Bridge tables sprouted from patio walls. Playing cards fluttered onto pads in a shower of pips. Martinis manifested on an oaken bench with egg-salad sandwiches. Music played.
All that's missing is the nuclear apocalypse! But like I said, we've got a whole year left.
Video of this episode is up on YouTube:
I've made it! I'm over the hump! I'm actually writing* my language-learning app in Swift!
Send an email expressing how proud you are of me to podcast@searls.co. Or if there's any news worth following that isn't about AI. Too much AI stuff lately.
*And by "I'm writing", I admit Claude Code is doing a lot of the heavy lifting here.
Hyperlinks:
Scott Werner, who is frustratingly good at writing what I'm thinking about LLMs, has a new post out where he compares being an "agentic" coder to being an octopus, with each arm being a separate instance of Claude Code independently thinking and acting on its own. It's a good post and you should read it.
In the middle, he said the thing that was what first came to mind when I saw the image of the octopus in this context:
Here's the thing about teams now:
Two developers on one codebase is like two octopuses sharing one coral reef. Technically possible. Practically ridiculous. Everybody's arms getting tangled. Ink everywhere. The coral is screaming (coral doesn't scream, but work with me here).
But one octopus with eight projects? That's just nature.
The more time I spend with coding agents, the more I become convinced that they are damn-near incompatible with working in teams. I've suggested this before, but I really think more people should be chewing on this. The bottleneck for software teams—the thing that's always made them less than the sum of their parts—is the handshake problem. It's the one thing from The Mythical Man-Month everyone remembers: "Adding manpower to a late software project makes it later."
For the last 50 years, this has been (quite reasonably) understood as the number of humans on a team. That the number of relationships between those humans in an organization's design could be used to compute an approximate productivity tax on the collective's broader efforts to encode some kind of intention into software.
If we have 8 humans working on a software project, we have (8 ⨉ 7) ÷ 2
or 28 relationships to manage, with each individual capable of and burdened by the need to bidirectionally seek shared understanding and consensus with one other for the purpose of coordinating their efforts.
Now imagine the team having 8 humans each juggling 8 sub-agents on a project. This figure balloons to (64 ⨉ 63) ÷ 2
or 2,016 relationships. In the good ol' days of 2022, this quadratic increase in communication cost for squaring the size of the team was enough to give people pause on its own. But when ⅞ of the team are AI agents, it adds an all-new wrinkle to the math: 1,764 of those connections are unidirectional. The agents can receive information and instruction but they lack durable institutional memory, they can't pipe up in meetings, and each has its view of the world bottlenecked behind a single operator. Each of those complications has the opportunity to dramatically compound the already-really-quite-bad errors we typically associate with large software teams. This is made even worse by the fact that a manager has no observable signal that their team's composition has changed so radically—they'll walk into the room and see the same eight nerds staring at their computers as ever before.
My theory on why this issue hasn't already triggered productivity meltdowns is a happy accident of circumstance, owing to the fact that the people currently trailblazing multi-agent workflows in earnest are highly-engaged, driven programmers—the go-getting early adopters who were using Rails in 2005 and Node.js in 2009. As a result, the median team of eight engineers may not even have one such developer—which means we haven't seen what deploying coding agents at scale will really look like yet. My prediction is that as these tools continue to go mainstream, things are going to go about as well as if you were to throw a dozen octopuses in an aquarium together.
If none of this is quite clicking with you, think of it this way. Team A has 8 programmers in a room working on a project. Team B has 8 technical analysts each managing a separate sub-team of 8 offshore developers somewhere in South Asia, replete with all the time zone and communication constraints those impose. We have a lot of data to indicate that Team B is in for a bad fucking time, but that scenario is effectively what mainstream adoption of coding agents as they exist today would represent.
Anyway, if your entire team are working to keep their coding agents' hoppers full (replete with subagents and juggling multiple tasks at a time), what is your effective team size by this measure? Am I wrong here? Is everything actually going great? Is coordination not suddenly much harder than it was before? Let me know.

Shout-out to Orta for pulling on the "full-breadth developer" thread with such a concrete, detailed accounting of his agentic coding experiences blog.puzzmo.com/posts/2025/07/30/six-weeks-of-claude-code/
Consider this one of a thousand signposts I'll erect for the sake of anyone on the journey to becoming a full-breadth developer. What's discussed below is exactly the sort of thing that will separate the people who successfully wrangle coding agents from the people doomed to be replaced by them.
This post by Jared Norman about the order in which we design computer programs got stuck in my craw as I was reading it:
When you build anything with code, you start somewhere. Knowing where you should start can be hard. This problem contributes to the difficulty of teaching programming. Many programmers can't even tell you how they decide where they start. It turns out that thinking of somewhere you could start and starting there is good enough for a lot of people.
Relatable.
Back when people talked about test-driven development, I spilled a lot of ink discussing "bottom-up" (Detroit-school) versus "outside-in" (London-school) design and the benefits and drawbacks of each. Both because outside-in TDD was more obscure and because it's a better fit for most application development, I exerted far too much effort building mocking libraries and teaching people how to use them well.
Whether that work had any lasting impact, who's to say. It kept me busy.
In the broader scope of software development, the discussion of where the fuck to even start when programming a computer can take many forms. Most often, the debate comes down to type systems and the degree to which somebody is obsessed with or repelled by them.
At the end of the day, every program is just a recipe. Some number of ingredients being mixed together over some number of steps. The particular order in which you write the recipe doesn't really matter. Instead, what matters is that you think deeply and carefully consider your approach. The ideal order is whatever will prompt the right thought at the right moment to do the right thing to produce the right solution. The best approach is ever-changing. It will vary from person to person and situation to situation and will change from day to day.
But it's easier to tell people to follow a prescriptive one-size-fits-most solution, like to adopt London-school TDD or to use your type system.
Jared wraps with:
You can build any kind of structure with any kind of technique. Hell, you can write pretty good object-oriented code in C. You'll find no hard laws of computer science here. Your entrypoint into the problem you're solving doesn't decide how your system will be structured.
The order you tackle components merely encourages certain kinds of designs.
In programming, it's seen as a cop-out to inject oneself into a spirited debate between two sides and butt in to say that the real answer is "it depends." But one reason the question of, "where do we start?" has been so fundamental to my programming career—especially as someone who can suffer crippling Blank Page Syndrome—is that there actually is a right answer to the question. The hard part? The only way to arrive at that answer is to think it through yourself. No shortcuts. No getting around it. And if you want to get better over time? That requires deliberate and continuous metacognition—thinking about one's own thinking—to an extent that vanishingly few programmers will ever realize, much less attempt.
I made Xcode's tests 60 times faster
Time is our most precious resource, as both humans and programmers.
An 8-hour workday contains 480 minutes. Out of the box, running a new iOS app's test suite from the terminal using xcodebuild test
takes over 25 seconds on my M4 MacBook Pro. After extracting my application code into a Swift package—such that the application project itself contains virtually no code at all—running swift test
against the same test suite now takes as little as 0.4 seconds. That's over 60 times faster.
Given 480 minutes, that's the difference between having a theoretical upper bound of 1152 potential actions per day and having 72,000.
If that number doesn't immediately mean anything to you, you're not alone. I've been harping on the importance of tightening this particular feedback loop my entire career. If you want to see the same point made with more charts and zeal, here's me saying the same shit a decade ago:
And yes, it's true that if you run tests through the Xcode GUI it's faster, but (1) that's no way to live, (2) it's still pretty damn slow, and (3) in a world where Claude Code exists and I want to constrain its shenanigans by running my tests in a hook, a 25-second turnaround time from the CLI is unacceptably slow.
Anyway, here's how I did it, so you can too.

AppleCare One is a great deal if you like Apple's more expensive products. An iPad Pro ($10.99/mo), Vision Pro ($24.99/mo), and Pro Display XDR ($17.99/mo) somehow adds up to $19.99.
That's $33.98/mo cheaper than ala carte pricing. apple.com/applecare/

Did Satya write this for current and former employees or did Satya write this for Satya? blogs.microsoft.com/blog/2025/07/24/recommitting-to-our-why-what-and-how/

Finally, vindication. I've been calling bullshit on resting meat since I first heard of it. Get the meat to the right temp and shove it in your face while it's still hot. You can rest when you're dead. seriouseats.com/meat-resting-science-11776272
Adding swift-format to your Xcode build
Xcode 16 and later come with swift-format baked in. Unfortunately, Xcode doesn't hook it up for you: aside from a one-off "Format File" menu item, you get no automatic formatting or linting on local builds—and zero guidance for Xcode Cloud.
Beginning with the end in mind, here's what I ended up adding or changing:
.
├── ci_scripts
│ ├── ci_pre_xcodebuild.sh
│ ├── format
│ └── lint
├── MyApp.xcodeproj
│ └── project.pbxproj
└── script -> ci_scripts/
Configuring swift-format
Since I'm new around here, I'm basically sticking with the defaults. The only rule I customized in my project's .swift-format
file was to set indents to 2 spaces. Personally, I rock massive fonts and zoom levels when I work, so the default 4-space indent can result in horizontal scrolling.
{
"indentation" : {
"spaces" : 2
}
}
Running swift-format in Xcode Cloud
Heads-up: if you wire swift-format into your local build you can skip this step. I'm laying it out anyway because sometimes it's handy to run these scripts only in the cloud—and starting with that flexibility costs nothing.
When you add custom scripts on Xcode Cloud, you can implement any or all of these three specially named hook scripts:
ci_scripts/ci_post_clone.sh
ci_scripts/ci_pre_xcodebuild.sh
ci_scripts/ci_post_xcodebuild.sh
If that feels limiting, it gets better: these scripts can call anything else inside ci_scripts. Because I always name my projects' script directory script/, I capitulated by putting everything in ci_scripts
and made a symlink:
# Create the directory
mkdir ci_scripts
# Add a script/ symlink
ln -s ci_scripts script
Create the formatting & linting scripts
Next, I created (and made executable) my pre-build hook script, a format script, and a lint script:
# Create the scripts
touch ci_scripts/ci_pre_xcodebuild.sh ci_scripts/lint ci_scripts/format
# Make them executable
chmod +x ci_scripts/ci_pre_xcodebuild.sh ci_scripts/lint ci_scripts/format
With that, a pre-build hook (which only runs in Xcode Cloud) can be written like this:
#!/bin/sh
# ci_scripts/ci_pre_xcodebuild.sh
# See: https://developer.apple.com/documentation/xcode/writing-custom-build-scripts
set -e
./lint
./format
The lint script looks like this (--strict
treats warnings as errors):
#!/bin/sh
# ci_scripts/lint
swift format lint --strict --parallel --recursive .
And my format script (which needs --in-place
to know it should overwrite files) is here:
#!/bin/sh
# ci_scripts/format
swift format --in-place --parallel --recursive .
Note that the above scripts use swift format
as a swift
subcommand, because the swift-format
executable is not on the PATH
of the sandboxed Xcode Cloud environment.
(Why bother formatting in CI if it won't commit changes? Because I'd rather learn ASAP that something's un-formattable than be surprised when I run ./script/format
later.)
Configuring formatting and linting for local builds
If you're like me, you'll want to lint and format on every local build as well:
In your project file, select your app target and navigate to the Build Phases tab. Click the plus (➕) icon and select "New Run Script Phase" to give yourself a place to write this little bit of shell magic:
"$SRCROOT/script/format"
"$SRCROOT/script/lint"
You'll also want to uncheck "Based on dependency analysis", since these scripts run across the whole codebase, it doesn't make sense to whitelist specific input and output files.
Finally, because Xcode 15+ sandboxes Run Scripts from the filesystem by default, you also need to go to the Build Settings tab of the target and set "User Script Sandboxing" to "No" in the target's Build Settings.
In MyApp.xcodeproj/project.pbxproj
you should see the setting reflected as:
ENABLE_USER_SCRIPT_SANDBOXING = NO
And that's it! Now, when building the app locally (e.g. Command-B), all the Swift source files in the project are linted and formatted. As mentioned above, if you complete this step you can go back and delete your ci_scripts/ci_pre_xcodebuild.sh
file.
Why is this so hard?
Great question! I'm disappointed but unsurprised by how few guides I found today to address issues like this, but ultimately the responsibility lies with Apple to provide batteries-included tooling and, failing that, documentation that points to solutions for common tasks.

The first draft of my "Full-breadth Developers" post included a throwaway line like "Forget 10x developers; think 100x" but then I came to my senses and deleted it. businessinsider.com/surge-ceo-ai-100x-engineers-2025-7

Never get high off your own supply. This guy must be new at this. futurism.com/openai-investor-chatgpt-mental-health
Video of this episode is up on YouTube:
Finally, a recommendation-heavy, full-mailbag show. Been a while.
New to the pod are achievements—watch your BreakingScore™ increase each time you write in to podcast@searls.co. The winner will receive nothing, probably.
Lynx:

I was red-pilled by Claude Code over 4th of July weekend. Its performance was incredible. Ever since, it's been unbelievably incompetent by comparison.
Now the AI bros tell me Anthropic's servers get slammed during US business hours and Claude becomes 70% stupider. It's 4pm on a Friday and I only realized because Claude stopped fucking everything up. Great job, everyone.