ARC (SOO) · 651-755-4900 (DM!)

The leanest org is the org of one.

We now live in an era of single players making change, building shit to survive. What I'm really saying is that the final economy is the freelance economy. That's pretty much it. The leanest org is the org of one.

I genuinely believe it's more fun to build with other people. But maybe it isn't required, if you think about it honestly. I don't want agreement or alignment when I'm working on something; it fucking sucks. You know what's great? An agent that never needs aligning.

I desperately want to find someone where it just fucking clicks, but it never works, dude. What do you want to do, why, how? We're not even doing anything hard, let's just do it, why are we pretending? But it's cool for now, bro. I'm chilling.

A six-month survey of 41 consumer products shows the same chat-sidebar layout shipping everywhere at once. Either we all had the same idea, or we ran out of ideas. A guess: both.

I opened 41 consumer apps in one sitting last month, note app, design tool, calendar, email client, two banks, the airline, the grocery thing, Spotify, my therapist's portal, and 34 of them had a chatbot panel anchored to the right edge of the screen. Same width. Same little sparkle icon. Same "Ask me anything" placeholder. I am not exaggerating.

There are two clean explanations and they're both true at the same time. One: the same three or four design systems, the same component libraries, and the same set of agentic IDEs are doing most of the work. When everyone's pulling from the same shelves, the shelves design the room. Two: "add an AI panel" is the dominant safe move on every product roadmap in 2026, because nobody gets fired for shipping the thing that's clearly working at OpenAI.

The thing nobody wants to say out loud is that this convergence is the opposite of taste. Taste is the willingness to do something a little weird because you can argue for it. What we have right now is a marketwide refusal to argue. The result reads as competence, every product looks polished, considered, on-trend, and it ships the same dull feeling everywhere.

I don't have a clean prescription. I do have a question I keep coming back to: in a market where the obvious move is everywhere at once, what does it look like to do the non-obvious one well? That's the actual brief. That's where the next interesting decade of consumer software gets made. The convergence is a fact. The response to it is still up for grabs.

The homescreen isn't dying as fast as the agent maximalists need it to.

There's a lot made of the death of the homescreen, and I think it's mostly a lie. People are not going to trust just integrating with a new piece of software for a long time, not without going to its webpage and clicking through a few buttons first. If for no other reason than this: the clicks are what fill the user with trust.

This bullshit that everything is going to be agent-to-agent is in full misalignment with how people actually use and discover software. UI, images, visuals: none of it is going away. Picture an agent silently watching content for you like Instagram, or signing you up for a new analytics tool with no screen in between. Nobody trusts that yet.

For the foreseeable future, dashboards are still required. Visuals, data you can feel, feedback you can see. That's the trust surface. The homepage isn't dead; it just moved, and pretending the screen disappears with it is wishful thinking.

We know you're a wrapper. Be decent about it.

Pricing pages are now the most-edited file in the repo and it kind of fucking sucks, dude. Teams are running campaigns and A/B tests on the price box that would make Meta squeamish. Can we fucking stop and have a little modesty?

We know you're a wrapper. Just be decent about it. It took you a fucking week. You are not Steve Jobs, Jesus Christ. It is genuinely upsetting to review the same pricing page a million times, or sit on a call picking at minute details that do not matter to anyone.

Focus on the product and the marketing, bro. The price will follow. Everything else is theater you're performing for yourself.

Most of what people call taste is just an eval they haven't written yet.

Taste won't save you. Almost every way I've seen taste discussed is something that can be encapsulated in an eval, which makes the whole conversation fucking retarded. Do you need taste to decide whether tabs go at the top or bottom of a page? To decide whether you need a load balancer? "Hold on, let me go set up a WAF on AWS, I'm a genius, fuck you." That is not taste. That is a checklist.

Unless you're doing something meaningfully valuable, solving hard problems, or keeping a project legible enough that great ideas can actually be molded into it, you are out of luck. So be entrepreneurial, or go deep into building software that builds software. Find something people want, then do it again. Everything else is cooked. I build mobile apps; that shit is fucking over, dude.

Go build a genuinely large-scale agent feedback loop with sub-agent compaction for managing the different kinds of drift. Build your own harness. If you've used LangChain (I don't anymore) and poked at Hugging Face (I don't anymore), at least you know what memory is, how routers hold it, why you might not want that, and how the offering degrades over time. If none of that means anything to you, you're fucking cooked, and so am I, probably. What I'm saying is: apply yourself. You live in interesting times, as the quote goes.

Never read the diff. (Okay, read some of it.)

Never look at your code. Never look at your old code. Don't look at the diff, just ship. This is the best era there's ever been: do a little manual verification and go. That's what I believe now.

...Not really. Good title though. Consider this the text-form version of getting rick-rolled, Jesus Christ.

But for real: build it, reveal it, write the test cases, then ship. If your components are segmented meaningfully, you'll be more than fine. The new era doesn't mean reading every line. It means verifying the right things and separating components hard enough that contamination can't spread across nodes. Ship. Just ship the right way.