The revenue numbers back this up. App Store grew 11% in 2025, Google Play 5%. There's still tons of unmet demand, especially for niche use cases that were never worth building before. Lower development costs mean these niches finally get served.

For apps that run locally—no servers, no cloud costs—subscriptions make no sense anymore. The only real cost is development, and that's becoming negligible.

This sucks for developers trying to make a living from apps. The competitive pressure is going to be brutal. But for users? It's great. People have been complaining about app subscription costs for years. There's that old complaint: "Why do I have to keep paying for software after I already paid $1000 for my iPhone?"

If one employee is using AI

your employer captures 100% of the value from you adopting AI. You get nothing, or at any rate, it ain’t gonna be 9x your salary. And everyone hates you now.

And you’re exhausted. You’re tired, Boss. You got nothing for it.

Compared to the 80', time moved slowly in the sense that news and events were spaced way out and society had time to reflect on them. Now it changes so fast we can’t even keep up, let alone reflect.

Crazy addicted early adopters like me are controlling the narrative and make it unrealistic
You can’t stop reading about it in the news; there’s nowhere to hide from it.
Panicking CEOs are leaning in hard to AI, often whiplashing it into their orgs.
Companies are capitalistic extraction machines and literally don’t know how to ease up.

and we’re all setting unrealistic standards for everyone else.

$/hour. "I told the grumbler group, you can’t control the numerator of this ratio. But you have significant control over the denominator. I pointed at the /hr for dramatic effect."

Why did such an experienced leader make such an terrible mistake?

The promises made didn't hold the reality delivered.

• switching to Perl would unlock the architecture we need, rebuilding from scratch would accelerate hiring and quality)
• velocity collapsed as the team relearned and rebuilt everything, burn rate jumped from 200K to 500K per month

One strategy: how you evaluated other language candidates?

Every technical debate is really two conversations: the visible and marketed one and the (stronger private) invisible one.

The real question is: can you afford to let it make your decisions?

Because the invisible conversation has a price tag. Industry research suggests that technology stack decisions account for 40-60% of total development costs over a product’s lifecycle. Research by Stripe found that developers spend 42% of their time on technical debt.

An better question is "what is this language going to cost us?" in velocity, technical debt, hiring difficulty, operational complexity.

spf13 published a framework to estimate it: https://spf13.com/p/the-9-factors/

"Vibe coding" is a trendy expression for "Automated coding".

Automated programming especially allows me to quickly build the tools I need so fast that every blacksmith that ever existed on this earth would envy me deeply.

With the automated coding, "we can finally get rid of all that middle work. That adapting layer of garbage we blindly accepted during these years. A huge amount of frameworks and libraries and tooling that has completely polluted software engineering, especially in web, mobile and desktop development."

The frameworks claim to solve three problems: simplification, automation and labour cost. "You unlock a feature that has nothing to do with engineering: you no longer need to hire a software engineer. You hire a React Developer.

Software engineering is back in a sense again: We have the chance again to get rid of useless complexity and keep working on the true and welcome complexity of our ideas, our features, our products. The complexity that matters. The complexity that is actually yours.

Automation and boilerplating have never been so cheap to overcome. I’ve been basically never writing twice the same line of code. I’m instantly building small tools I need, purpose built, exactly shaped around the problem at hand. I don’t need any fancy monorepo manager. A simple Makefile covers 100% of my needs for 99% of my use cases.

Bash, makefiles, ...

Think about it

1.There are three states of being. Not knowing, action and completion.00

2. Accept that everything is a draft. It helps to get it done.
3. There is no editing stage.
4. Pretending you know what you’re doing is almost the same as knowing what you are doing, so just 5. Accept that you know what you’re doing even if you don’t and do it.
5. Banish procrastination. If you wait more than a week to get an idea done, abandon it.
6. The point of being done is not to finish but to get other things done.
7. Once you’re done you can throw it away.
8. Laugh at perfection. It’s boring and keeps you from being done.
9. People without dirty hands are wrong. Doing something makes you right.
10. Failure counts as done. So do mistakes.
11. Destruction is a variant of done.
12. If you have an idea and publish it on the internet, that counts as a ghost of done.
13. Done is the engine of more.

There is also an illustration for it

Bad programmers worry about the code. Good programmers worry about data structures and their relationships.

git actually has a simple design, with stable and reasonably well-documented data structures. In fact, I'm a huge proponent of designing your code around the data, rather than the other way around, and I think it's one of the reasons git has been fairly successful

The actionable tip here is to start with the data. Try to reduce code complexity through stricter types on your interfaces or databases. Spend extra time thinking through the data structures ahead of time.

That's awesome for dev and UX feedback. It w. It follows the trend that the tool only exports into a human readable format and that's more than enough.
The UI or the interpretation of the JSON can be built later on.

Uxnote is an annotation bar for mockups and websites. Drop a single script to get text highlights, element pins, numbered cards, color theming, a dimmed focus mode, import/export, and email handoff. No plugin and no backend required.

It's similar to https://loomflows.com/ but minimalistic and provide full-control over the data.

Idea -> Programming -> Feedback. Repeat.

Half of those [students] who started from scratch had working designs.

IndexedDB built with 92% successful tests

I enjoyed the experience and don’t regret it, but experiments like this cheapen the efforts I’ve made over the years. It reduces the value of things. I think this is partly why so many of us have a knee-jerk reaction to reject these tools: if they work, then they’re frankly insulting.

Simon Willison predicts a webbrowser will be built by AI until 2029.

The 2026 State of the Game Industry report (SOTI)—an annual survey conducted by GDC Festival of Gaming—indicates that one in four game developers directly experienced a layoff over the past two years.

"Leadership failed to see that the COVID-era boom was not permanent

It seems companies have a tendency to be too greedy. It's a pattern I see more and more.

I use code, LEGO, words, pictures, wood, and empathy to create stuff. Let's make the world a bit more interesting.

A method applied from Programming as Theory Building from Peter Naur to solve the problem about a behavior of neovim.

"abstraction" in mathematics means to use a higher-level concept that carries fewer assumptions but covers a broader superset of cases. complexity is removed for the sake of generalizability. "abstraction" in programming means to paper over the underlying workings of a system with shorthands or conveniences. complexity is added so you can pretend it isn't there. no matter how you dress it up, when you're using a computer, you are always somewhere in the jenga pagoda

master the fundamentals, understand how they're composed into abstractions, and you can pick almost anything up as you go.

So how to master them?

What is a kata: basic programming concepts as akin to martial arts kata. To be really good, you don't need to study any particular big thing. you need to practice and understand the small things, over and over, until they're second nature.

Frameworks and librairies are domains of specialists.

The rest is content about programming:

Kata one: variables, flow control, scope, functions; memory semantics stack and heap
Kata two: indirection and recursion; memory semantics structs, arrays, enums

Paradigms: imperative and oop
Disgression two: odds and ends. OS, IDEs, VCS, programming loop with feedback and responses,

Kata three: registers, jumps, calling convention

once you are are good at programming, you will have literally hundreds of ideas of things to do but lack the time to do more than two or three at once. so enjoy it while it lasts

Yes indeed

The end: further reading

the important thing to remember is that it's not enough to be valuable. you must be legibly valuable. this trips up people who are not used to cultivating an appearance.